root/src/xdisp.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. it_char_has_category
  2. char_can_wrap_before
  3. char_can_wrap_after
  4. fill_column_indicator_column
  5. redisplay_other_windows
  6. wset_redisplay
  7. fset_redisplay
  8. bset_redisplay
  9. bset_update_mode_line
  10. wset_update_mode_line
  11. ATTRIBUTE_FORMAT_PRINTF
  12. ATTRIBUTE_FORMAT_PRINTF
  13. window_text_bottom_y
  14. window_box_width
  15. window_box_height
  16. window_box_left_offset
  17. window_box_right_offset
  18. window_box_left
  19. window_box_right
  20. window_box
  21. window_box_edges
  22. line_bottom_y
  23. DEFUN
  24. default_line_pixel_height
  25. string_from_display_spec
  26. window_hscroll_limited
  27. reset_box_start_end_flags
  28. pos_visible_p
  29. check_char_and_length
  30. string_pos_nchars_ahead
  31. string_pos
  32. c_string_pos
  33. number_of_chars
  34. compute_string_pos
  35. estimate_mode_line_height
  36. pixel_to_glyph_coords
  37. x_y_to_hpos_vpos
  38. frame_to_window_pixel_xy
  39. get_glyph_string_clip_rects
  40. get_glyph_string_clip_rect
  41. get_phys_cursor_geometry
  42. remember_mouse_glyph
  43. adjust_window_ends
  44. hscrolling_current_line_p
  45. safe_eval_handler
  46. safe__call
  47. safe_call
  48. safe_call1
  49. safe__call1
  50. safe_eval
  51. safe__eval
  52. safe_call2
  53. CHECK_IT
  54. CHECK_WINDOW_END
  55. init_iterator
  56. get_narrowed_width
  57. get_narrowed_len
  58. get_medium_narrowing_begv
  59. get_medium_narrowing_zv
  60. get_nearby_bol_pos
  61. get_small_narrowing_begv
  62. get_large_narrowing_begv
  63. get_large_narrowing_zv
  64. unwind_narrowed_begv
  65. start_display
  66. in_ellipses_for_invisible_text_p
  67. init_from_display_pos
  68. init_to_row_start
  69. init_to_row_end
  70. handle_stop
  71. compute_stop_pos
  72. compute_display_string_pos
  73. compute_display_string_end
  74. handle_fontified_prop
  75. face_at_pos
  76. handle_face_prop
  77. underlying_face_id
  78. face_before_or_after_it_pos
  79. handle_invisible_prop
  80. setup_for_ellipsis
  81. find_display_property
  82. get_display_property
  83. display_min_width
  84. handle_display_prop
  85. handle_display_spec
  86. display_prop_end
  87. handle_single_display_spec
  88. display_prop_intangible_p
  89. single_display_spec_string_p
  90. display_prop_string_p
  91. string_buffer_position_lim
  92. string_buffer_position
  93. handle_composition_prop
  94. handle_overlay_change
  95. next_overlay_string
  96. compare_overlay_entries
  97. load_overlay_strings
  98. get_overlay_strings_1
  99. get_overlay_strings
  100. push_it
  101. iterate_out_of_display_property
  102. restore_face_box_flags
  103. pop_it
  104. back_to_previous_line_start
  105. strings_with_newlines
  106. forward_to_next_line_start
  107. back_to_previous_visible_line_start
  108. reseat_at_previous_visible_line_start
  109. reseat_at_next_visible_line_start
  110. reseat
  111. reseat_1
  112. reseat_to_string
  113. lookup_glyphless_char_display
  114. merge_escape_glyph_face
  115. merge_glyphless_glyph_face
  116. forget_escape_and_glyphless_faces
  117. get_next_display_element
  118. set_iterator_to_next
  119. next_element_from_display_vector
  120. get_visually_first_element
  121. next_element_from_string
  122. next_element_from_c_string
  123. next_element_from_ellipsis
  124. next_element_from_image
  125. next_element_from_xwidget
  126. next_element_from_stretch
  127. compute_stop_pos_backwards
  128. handle_stop_backwards
  129. next_element_from_buffer
  130. next_element_from_composition
  131. move_it_in_display_line_to
  132. move_it_in_display_line
  133. move_it_to
  134. move_it_vertically_backward
  135. move_it_vertically
  136. move_it_past_eol
  137. move_it_by_lines
  138. partial_line_height
  139. fast_move_it_horizontally
  140. in_display_vector_p
  141. window_text_pixel_size
  142. DEFUN
  143. format_nargs
  144. add_to_log
  145. vadd_to_log
  146. message_log_maybe_newline
  147. message_dolog
  148. message_log_check_duplicate
  149. message3
  150. message_to_stderr
  151. message3_nolog
  152. message1
  153. message1_nolog
  154. message_with_string
  155. ATTRIBUTE_FORMAT_PRINTF
  156. message
  157. update_echo_area
  158. ensure_echo_area_buffers
  159. with_echo_area_buffer
  160. with_echo_area_buffer_unwind_data
  161. unwind_with_echo_area_buffer
  162. setup_echo_area_for_printing
  163. display_echo_area
  164. display_echo_area_1
  165. resize_echo_area_exactly
  166. resize_mini_window_1
  167. resize_mini_window
  168. current_message
  169. current_message_1
  170. push_message
  171. restore_message
  172. pop_message_unwind
  173. check_message_stack
  174. clear_message_stack
  175. truncate_echo_area
  176. truncate_message_1
  177. set_message
  178. set_message_1
  179. clear_message
  180. clear_garbaged_frames
  181. echo_area_display
  182. window_buffer_changed
  183. mode_line_update_needed
  184. window_frozen_p
  185. format_mode_line_unwind_data
  186. unwind_format_mode_line
  187. store_mode_line_noprop_char
  188. store_mode_line_noprop
  189. gui_consider_frame_title
  190. needs_no_redisplay
  191. prepare_menu_bars
  192. update_menu_bar
  193. restore_selected_window
  194. restore_frame_selected_window
  195. update_tab_bar
  196. display_tab_bar
  197. build_desired_tab_bar_string
  198. display_tab_bar_line
  199. tab_bar_height
  200. redisplay_tab_bar
  201. tab_bar_item_info
  202. get_tab_bar_item
  203. handle_tab_bar_click
  204. note_tab_bar_highlight
  205. tty_get_tab_bar_item
  206. tty_handle_tab_bar_click
  207. update_tool_bar
  208. build_desired_tool_bar_string
  209. display_tool_bar_line
  210. tool_bar_height
  211. redisplay_tool_bar
  212. tool_bar_item_info
  213. get_tool_bar_item
  214. handle_tool_bar_click_with_device
  215. handle_tool_bar_click
  216. note_tool_bar_highlight
  217. hscroll_window_tree
  218. hscroll_windows
  219. debug_method_add
  220. text_outside_line_unchanged_p
  221. redisplay
  222. overlay_arrow_string_or_property
  223. overlay_arrow_in_current_buffer_p
  224. overlay_arrows_changed_p
  225. update_overlay_arrows
  226. overlay_arrow_at_row
  227. check_point_in_composition
  228. reconsider_clip_changes
  229. propagate_buffer_redisplay
  230. redisplay_internal
  231. unwind_redisplay_preserve_echo_area
  232. redisplay_preserve_echo_area
  233. unwind_redisplay
  234. unwind_display_working_on_window
  235. mark_window_display_accurate_1
  236. mark_window_display_accurate
  237. disp_char_vector
  238. block_buffer_flips
  239. unblock_buffer_flips
  240. buffer_flipping_blocked_p
  241. redisplay_windows
  242. redisplay_window_error
  243. redisplay_window_0
  244. redisplay_window_1
  245. update_redisplay_ticks
  246. set_cursor_from_row
  247. run_window_scroll_functions
  248. cursor_row_fully_visible_p
  249. try_scrolling
  250. compute_window_start_on_continuation_line
  251. try_cursor_movement
  252. set_vertical_scroll_bar
  253. set_horizontal_scroll_bar
  254. window_start_acceptable_p
  255. DEFUN
  256. redisplay_window
  257. try_window
  258. try_window_reusing_current_matrix
  259. find_last_row_displaying_text
  260. find_last_unchanged_at_beg_row
  261. find_first_unchanged_at_end_row
  262. sync_frame_with_window_matrix_rows
  263. row_containing_pos
  264. try_window_id
  265. dump_glyph_row
  266. dump_glyph
  267. dump_glyph_row
  268. DEFUN
  269. DEFUN
  270. DEFUN
  271. get_overlay_arrow_glyph_row
  272. insert_left_trunc_glyphs
  273. row_hash
  274. compute_line_metrics
  275. clear_position
  276. append_space_for_newline
  277. extend_face_to_end_of_line
  278. trailing_whitespace_p
  279. highlight_trailing_whitespace
  280. row_for_charpos_p
  281. cursor_row_p
  282. push_prefix_prop
  283. get_it_property
  284. get_line_prefix_it_property
  285. handle_line_prefix
  286. unproduce_glyphs
  287. find_row_edges
  288. display_count_lines_logically
  289. display_count_lines_visually
  290. maybe_produce_line_number
  291. should_produce_line_number
  292. row_text_area_empty
  293. display_line
  294. DEFUN
  295. DEFUN
  296. DEFUN
  297. display_menu_bar
  298. deep_copy_glyph_row
  299. display_tty_menu_item
  300. redisplay_mode_lines
  301. display_mode_lines
  302. display_mode_line
  303. move_elt_to_front
  304. safe_set_text_properties
  305. display_mode_element
  306. store_mode_line_string
  307. pint2str
  308. pint2hrstr
  309. decode_mode_spec_coding
  310. percent99
  311. decode_mode_spec
  312. count_lines
  313. display_count_lines
  314. display_string
  315. invisible_prop
  316. DEFUN
  317. calc_pixel_width_or_height
  318. get_font_ascent_descent
  319. dump_glyph_string
  320. init_glyph_string
  321. append_glyph_string_lists
  322. prepend_glyph_string_lists
  323. append_glyph_string
  324. get_char_face_and_encoding
  325. get_glyph_face_and_encoding
  326. get_char_glyph_code
  327. fill_composite_glyph_string
  328. fill_gstring_glyph_string
  329. fill_glyphless_glyph_string
  330. fill_glyph_string
  331. fill_image_glyph_string
  332. fill_xwidget_glyph_string
  333. fill_stretch_glyph_string
  334. get_per_char_metric
  335. normal_char_ascent_descent
  336. normal_char_height
  337. gui_get_glyph_overhangs
  338. left_overwritten
  339. left_overwriting
  340. right_overwritten
  341. right_overwriting
  342. set_glyph_string_background_width
  343. glyph_string_containing_background_width
  344. compute_overhangs_and_x
  345. draw_glyphs
  346. font_for_underline_metrics
  347. append_glyph
  348. append_composite_glyph
  349. take_vertical_position_into_account
  350. produce_image_glyph
  351. produce_xwidget_glyph
  352. append_stretch_glyph
  353. produce_stretch_glyph
  354. produce_special_glyphs
  355. pad_mode_line
  356. calc_line_height_property
  357. append_glyphless_glyph
  358. produce_glyphless_glyph
  359. gui_produce_glyphs
  360. gui_write_glyphs
  361. gui_insert_glyphs
  362. gui_clear_end_of_line
  363. get_specified_cursor_type
  364. set_frame_cursor_types
  365. get_window_cursor_type
  366. notice_overwritten_cursor
  367. gui_fix_overlapping_area
  368. draw_phys_cursor_glyph
  369. erase_phys_cursor
  370. display_and_set_cursor
  371. update_window_cursor
  372. update_cursor_in_window_tree
  373. gui_update_cursor
  374. gui_clear_cursor
  375. draw_row_with_mouse_face
  376. show_mouse_face
  377. clear_mouse_face
  378. coords_in_mouse_face_p
  379. cursor_in_mouse_face_p
  380. rows_from_pos_range
  381. mouse_face_from_buffer_pos
  382. fast_find_string_pos
  383. mouse_face_from_string_pos
  384. on_hot_spot_p
  385. find_hot_spot
  386. define_frame_cursor1
  387. note_mode_line_or_margin_highlight
  388. note_mouse_highlight
  389. gui_clear_window_mouse_face
  390. cancel_mouse_face
  391. expose_area
  392. expose_line
  393. expose_overlaps
  394. phys_cursor_in_rect_p
  395. gui_draw_vertical_border
  396. gui_draw_right_divider
  397. gui_draw_bottom_divider
  398. expose_window
  399. expose_window_tree
  400. expose_frame
  401. gui_intersect_rectangles
  402. syms_of_xdisp
  403. init_xdisp
  404. show_hourglass
  405. start_hourglass
  406. cancel_hourglass
  407. adjust_glyph_width_for_mouse_face
  408. get_cursor_offset_for_mouse_face
     1 /* Display generation from window structure and buffer text.
     2 
     3 Copyright (C) 1985-2023 Free Software Foundation, Inc.
     4 
     5 This file is part of GNU Emacs.
     6 
     7 GNU Emacs is free software: you can redistribute it and/or modify
     8 it under the terms of the GNU General Public License as published by
     9 the Free Software Foundation, either version 3 of the License, or (at
    10 your option) any later version.
    11 
    12 GNU Emacs is distributed in the hope that it will be useful,
    13 but WITHOUT ANY WARRANTY; without even the implied warranty of
    14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15 GNU General Public License for more details.
    16 
    17 You should have received a copy of the GNU General Public License
    18 along with GNU Emacs.  If not, see <https://www.gnu.org/licenses/>.  */
    19 
    20 /* New redisplay written by Gerd Moellmann <gerd@gnu.org>.
    21 
    22    Redisplay.
    23 
    24    Emacs separates the task of updating the display from code
    25    modifying global state, e.g. buffer text.  This way functions
    26    operating on buffers don't also have to be concerned with updating
    27    the display.
    28 
    29    Updating the display is triggered by the Lisp interpreter when it
    30    decides it's time to do it.  This is done either automatically for
    31    you as part of the interpreter's command loop or as the result of
    32    calling Lisp functions like `sit-for'.  The C function
    33    `redisplay_internal' in xdisp.c is the only entry into the inner
    34    redisplay code.
    35 
    36    The following diagram shows how redisplay code is invoked.  As you
    37    can see, Lisp calls redisplay and vice versa.
    38 
    39    Under window systems like X, some portions of the redisplay code
    40    are also called asynchronously, due to mouse movement or expose
    41    events.  "Asynchronously" in this context means that any C function
    42    which calls maybe_quit or process_pending_signals could enter
    43    redisplay via expose_frame and/or note_mouse_highlight, if X events
    44    were recently reported to Emacs about mouse movements or frame(s)
    45    that were exposed.  And such redisplay could invoke the Lisp
    46    interpreter, e.g. via the :eval forms in mode-line-format, and as
    47    result the global state could change.  It is therefore very
    48    important that C functions which might cause such "asynchronous"
    49    redisplay, but cannot tolerate the results, use
    50    block_input/unblock_input around code fragments which assume that
    51    global Lisp state doesn't change.  If you don't follow this rule,
    52    you will encounter bugs which are very hard to explain.  One place
    53    that needs to take such precautions is timer_check, some of whose
    54    code cannot tolerate changes in timer alists while it processes
    55    timers.
    56 
    57    +--------------+   redisplay     +----------------+
    58    | Lisp machine |---------------->| Redisplay code |<--+
    59    +--------------+   (xdisp.c)     +----------------+   |
    60           ^                                  |           |
    61           +----------------------------------+           |
    62             Block input to prevent this when             |
    63             called asynchronously!                       |
    64                                                          |
    65                     note_mouse_highlight (asynchronous)  |
    66                                                          |
    67                                     X mouse events  -----+
    68                                                          |
    69                             expose_frame (asynchronous)  |
    70                                                          |
    71                                    X expose events  -----+
    72 
    73    What does redisplay do?  Obviously, it has to figure out somehow what
    74    has been changed since the last time the display has been updated,
    75    and to make these changes visible.  Preferably it would do that in
    76    a moderately intelligent way, i.e. fast.
    77 
    78    Changes in buffer text can be deduced from window and buffer
    79    structures, and from some global variables like `beg_unchanged' and
    80    `end_unchanged'.  The contents of the display are additionally
    81    recorded in a `glyph matrix', a two-dimensional matrix of glyph
    82    structures.  Each row in such a matrix corresponds to a line on the
    83    display, and each glyph in a row corresponds to a column displaying
    84    a character, an image, or what else.  This matrix is called the
    85    `current glyph matrix' or `current matrix' in redisplay
    86    terminology.
    87 
    88    For buffer parts that have been changed since the last update, a
    89    second glyph matrix is constructed, the so called `desired glyph
    90    matrix' or short `desired matrix'.  Current and desired matrix are
    91    then compared to find a cheap way to update the display, e.g. by
    92    reusing part of the display by scrolling lines.  The actual update
    93    of the display of each window by comparing the desired and the
    94    current matrix is done by `update_window', which calls functions
    95    which draw to the glass (those functions are specific to the type
    96    of the window's frame: X, w32, NS, etc.).
    97 
    98    Once the display of a window on the glass has been updated, its
    99    desired matrix is used to update the corresponding rows of the
   100    current matrix, and then the desired matrix is discarded.
   101 
   102    You will find a lot of redisplay optimizations when you start
   103    looking at the innards of redisplay.  The overall goal of all these
   104    optimizations is to make redisplay fast because it is done
   105    frequently.  Some of these optimizations are implemented by the
   106    following functions:
   107 
   108     . try_cursor_movement
   109 
   110       This function tries to update the display if the text in the
   111       window did not change and did not scroll, only point moved, and
   112       it did not move off the displayed portion of the text.
   113 
   114     . try_window_reusing_current_matrix
   115 
   116       This function reuses the current matrix of a window when text
   117       has not changed, but the window start changed (e.g., due to
   118       scrolling).
   119 
   120     . try_window_id
   121 
   122       This function attempts to redisplay a window by reusing parts of
   123       its existing display.  It finds and reuses the part that was not
   124       changed, and redraws the rest.  (The "id" part in the function's
   125       name stands for "insert/delete", not for "identification" or
   126       somesuch.)
   127 
   128     . try_window
   129 
   130       This function performs the full, unoptimized, redisplay of a
   131       single window assuming that its fonts were not changed and that
   132       the cursor will not end up in the scroll margins.  (Loading
   133       fonts requires re-adjustment of dimensions of glyph matrices,
   134       which makes this method impossible to use.)
   135 
   136    The optimizations are tried in sequence (some can be skipped if
   137    it is known that they are not applicable).  If none of the
   138    optimizations were successful, redisplay calls redisplay_windows,
   139    which performs a full redisplay of all windows.
   140 
   141    Note that there's one more important optimization up Emacs's
   142    sleeve, but it is related to actually redrawing the potentially
   143    changed portions of the window/frame, not to reproducing the
   144    desired matrices of those potentially changed portions.  Namely,
   145    the function update_frame and its subroutines, which you will find
   146    in dispnew.c, compare the desired matrices with the current
   147    matrices, and only redraw the portions that changed.  So it could
   148    happen that the functions in this file for some reason decide that
   149    the entire desired matrix needs to be regenerated from scratch, and
   150    still only parts of the Emacs display, or even nothing at all, will
   151    be actually delivered to the glass, because update_frame has found
   152    that the new and the old screen contents are similar or identical.
   153 
   154    Desired matrices.
   155 
   156    Desired matrices are always built per Emacs window.  It is
   157    important to know that a desired matrix is in general "sparse": it
   158    only has some of the glyph rows "enabled".  This is because
   159    redisplay tries to optimize its work, and thus only generates
   160    glyphs for rows that need to be updated on the screen.  Rows that
   161    don't need to be updated are left "disabled", and their contents
   162    should be ignored.
   163 
   164    The function `display_line' is the central function to look at if
   165    you are interested in how the rows of the desired matrix are
   166    produced.  It constructs one row in a desired matrix given an
   167    iterator structure containing both a buffer position and a
   168    description of the environment in which the text is to be
   169    displayed.  But this is too early, read on.
   170 
   171    Glyph rows.
   172 
   173    A glyph row is an array of `struct glyph', where each glyph element
   174    describes a "display element" to be shown on the screen.  More
   175    accurately, a glyph row can have up to 3 different arrays of
   176    glyphs: one each for every display margins, and one for the "text
   177    area", where buffer text is displayed.  The text-area glyph array
   178    is always present, whereas the arrays for the marginal areas are
   179    present (non-empty) only if the corresponding display margin is
   180    shown in the window.  If the glyph array for a marginal area is not
   181    present its beginning and end coincide, i.e. such arrays are
   182    actually empty (they contain no glyphs).  Frame glyph matrices, used
   183    on text-mode terminals (see below) never have marginal areas; they
   184    treat the entire frame-wide row of glyphs as a single large "text
   185    area".
   186 
   187    Iteration over buffer and strings.
   188 
   189    Characters and pixmaps displayed for a range of buffer text depend
   190    on various settings of buffers and windows, on overlays and text
   191    properties, on display tables, on selective display.  The good news
   192    is that all this hairy stuff is hidden behind a small set of
   193    interface functions taking an iterator structure (`struct it')
   194    argument.
   195 
   196    Iteration over things to be displayed is then simple.  It is
   197    started by initializing an iterator with a call to `init_iterator',
   198    passing it the buffer position where to start iteration.  For
   199    iteration over strings, pass -1 as the position to `init_iterator',
   200    and call `reseat_to_string' when the string is ready, to initialize
   201    the iterator for that string.  Thereafter, calls to
   202    `get_next_display_element' fill the iterator structure with
   203    relevant information about the next thing to display.  Calls to
   204    `set_iterator_to_next' move the iterator to the next thing.
   205 
   206    Besides this, an iterator also contains information about the
   207    display environment in which glyphs for display elements are to be
   208    produced.  It has fields for the width and height of the display,
   209    the information whether long lines are truncated or continued, a
   210    current X and Y position, the face currently in effect, and lots of
   211    other stuff you can better see in dispextern.h.
   212 
   213    The "stop position".
   214 
   215    Some of the fields maintained by the iterator change relatively
   216    infrequently.  These include the face of the characters, whether
   217    text is invisible, the object (buffer or display or overlay string)
   218    being iterated, character composition info, etc.  For any given
   219    buffer or string position, the sources of information that affects
   220    the display can be determined by calling the appropriate
   221    primitives, such as `Fnext_single_property_change', but both these
   222    calls and the processing of their return values is relatively
   223    expensive.  To optimize redisplay, the display engine checks these
   224    sources of display information only when needed, not for every
   225    character.  To that end, it always maintains the position of the
   226    next place where it must stop and re-examine all those potential
   227    sources.  This is called "the stop position" and is stored in the
   228    `stop_charpos' field of the iterator.  The stop position is updated
   229    by `compute_stop_pos', which is called whenever the iteration
   230    reaches the current stop position and processes it.  Processing a
   231    stop position is done by `handle_stop', which invokes a series of
   232    handlers, one each for every potential source of display-related
   233    information; see the `it_props' array for those handlers.  For
   234    example, one handler is `handle_face_prop', which detects changes
   235    in face properties, and supplies the face ID that the iterator will
   236    use for all the glyphs it generates up to the next stop position;
   237    this face ID is the result of "realizing" the face specified by the
   238    relevant text properties at this position (see xfaces.c).  Each
   239    handler called by `handle_stop' processes the sources of display
   240    information for which it is "responsible", and returns a value
   241    which tells `handle_stop' what to do next.
   242 
   243    Once `handle_stop' returns, the information it stores in the
   244    iterator fields will not be refreshed until the iteration reaches
   245    the next stop position, which is computed by `compute_stop_pos'
   246    called at the end of `handle_stop'.  `compute_stop_pos' examines
   247    the buffer's or string's interval tree to determine where the text
   248    properties change, finds the next position where overlays and
   249    character composition can change, and stores in `stop_charpos' the
   250    closest position where any of these factors should be reconsidered.
   251 
   252    Handling of the stop position is done as part of the code in
   253    `get_next_display_element'.
   254 
   255    Producing glyphs.
   256 
   257    Glyphs in a desired matrix are normally constructed in a loop
   258    calling `get_next_display_element' and then `PRODUCE_GLYPHS'.  The
   259    call to `PRODUCE_GLYPHS' will fill the iterator structure with
   260    pixel information about the element being displayed and at the same
   261    time will produce glyphs for it.  If the display element fits on
   262    the line being displayed, `set_iterator_to_next' is called next,
   263    otherwise the glyphs produced are discarded, and `display_line'
   264    marks this glyph row as a "continued line".  The function
   265    `display_line' is the workhorse of filling glyph rows in the
   266    desired matrix with glyphs.  In addition to producing glyphs, it
   267    also handles line truncation and continuation, word wrap, and
   268    cursor positioning (for the latter, see `set_cursor_from_row').
   269 
   270    Frame matrices.
   271 
   272    That just couldn't be all, could it?  What about terminal types not
   273    supporting operations on sub-windows of the screen (a.k.a. "TTY" or
   274    "text-mode terminals")?  To update the display on such a terminal,
   275    window-based glyph matrices are not well suited.  To be able to
   276    reuse part of the display (scrolling lines up and down), we must
   277    instead have a view of the whole screen.  This is what `frame
   278    matrices' are for.  They are a trick.
   279 
   280    Frames on text terminals have a glyph pool.  Windows on such a
   281    frame sub-allocate their glyph memory from their frame's glyph
   282    pool.  The frame itself is given its own glyph matrices.  By
   283    coincidence---or maybe something else---rows in window glyph
   284    matrices are slices of corresponding rows in frame matrices.  Thus
   285    writing to window matrices implicitly updates a frame matrix which
   286    provides us with the view of the whole screen that we originally
   287    wanted to have without having to move many bytes around.  Then
   288    updating all the visible windows on text-terminal frames is done by
   289    using the frame matrices, which allows frame-global optimization of
   290    what is actually written to the glass.
   291 
   292    Frame matrices don't have marginal areas, only a text area.  That
   293    is, the entire row of glyphs that spans the width of a text-mode
   294    frame is treated as a single large "text area" for the purposes of
   295    manipulating and updating a frame glyph matrix.
   296 
   297    To be honest, there is a little bit more done for frame matrices,
   298    but not much more.  If you plan to extend that code, take a look at
   299    dispnew.c.  The function build_frame_matrix is a good starting
   300    point.
   301 
   302    Simulating display.
   303 
   304    Some of Emacs commands and functions need to take display layout
   305    into consideration.  For example, C-n moves to the next screen
   306    line, but to implement that, Emacs needs to find the buffer
   307    position which is directly below the cursor position on display.
   308    This is not trivial when buffer display includes variable-size
   309    elements such as different fonts, tall images, etc.
   310 
   311    To solve this problem, the display engine implements several
   312    functions that can move through buffer text in the same manner as
   313    `display_line' and `display_string' do, but without producing any
   314    glyphs for the glyph matrices.  The workhorse of this is
   315    `move_it_in_display_line_to'.  Its code and logic are very similar
   316    to `display_line', but it differs in two important aspects: it
   317    doesn't produce glyphs for any glyph matrix, and it returns a
   318    status telling the caller how it ended the iteration: whether it
   319    reached the required position, hit the end of line, arrived at the
   320    window edge without exhausting the buffer's line, etc.  Since the
   321    glyphs are not produced, the layout information available to the
   322    callers of this function is what is recorded in `struct it' by the
   323    iteration process.
   324 
   325    Several higher-level functions call `move_it_in_display_line_to' to
   326    perform more complex tasks: `move_it_by_lines' can move N lines up
   327    or down from a given buffer position and `move_it_to' can move to a
   328    given buffer position or to a given X or Y pixel coordinate.
   329 
   330    These functions are called by the display engine itself as well,
   331    when it needs to make layout decisions before producing the glyphs.
   332    For example, one of the first things to decide when redisplaying a
   333    window is where to put the `window-start' position; if the window
   334    is to be recentered (the default), Emacs makes that decision by
   335    starting from the position of point, then moving up the number of
   336    lines corresponding to half the window height using
   337    `move_it_by_lines'.
   338 
   339    Bidirectional display.
   340 
   341    Bidirectional display adds quite some hair to this already complex
   342    design.  The good news are that a large portion of that hairy stuff
   343    is hidden in bidi.c behind only 3 interfaces.  bidi.c implements a
   344    reordering engine which is called by `set_iterator_to_next' and
   345    returns the next character to display in the visual order.  See
   346    commentary on bidi.c for more details.  As far as redisplay is
   347    concerned, the effect of calling `bidi_move_to_visually_next', the
   348    main interface of the reordering engine, is that the iterator gets
   349    magically placed on the buffer or string position that is to be
   350    displayed next in the visual order.  In other words, a linear
   351    iteration through the buffer/string is replaced with a non-linear
   352    one.  All the rest of the redisplay is oblivious to the bidi
   353    reordering.
   354 
   355    Well, almost oblivious---there are still complications, most of
   356    them due to the fact that buffer and string positions no longer
   357    change monotonously with glyph indices in a glyph row.  Moreover,
   358    for continued lines, the buffer positions may not even be
   359    monotonously changing with vertical positions.  Also, accounting
   360    for face changes, overlays, etc. becomes more complex because
   361    non-linear iteration could potentially skip many positions with
   362    such changes, and then cross them again on the way back (see
   363    `handle_stop_backwards')...
   364 
   365    One other prominent effect of bidirectional display is that some
   366    paragraphs of text need to be displayed starting at the right
   367    margin of the window---the so-called right-to-left, or R2L
   368    paragraphs.  R2L paragraphs are displayed with R2L glyph rows,
   369    which have their `reversed_p' flag set.  The bidi reordering engine
   370    produces characters in such rows starting from the character which
   371    should be the rightmost on display.  `PRODUCE_GLYPHS' then reverses
   372    the order, when it fills up the glyph row whose `reversed_p' flag
   373    is set, by prepending each new glyph to what is already there,
   374    instead of appending it.  When the glyph row is complete, the
   375    function `extend_face_to_end_of_line' fills the empty space to the
   376    left of the leftmost character with special glyphs, which will
   377    display as, well, empty.  On text terminals, these special glyphs
   378    are simply blank characters.  On graphics terminals, there's a
   379    single stretch glyph of a suitably computed width.  Both the blanks
   380    and the stretch glyph are given the face of the background of the
   381    line.  This way, the terminal-specific back-end can still draw the
   382    glyphs left to right, even for R2L lines.
   383 
   384    Bidirectional display and character compositions.
   385 
   386    Some scripts cannot be displayed by drawing each character
   387    individually, because adjacent characters change each other's shape
   388    on display.  For example, Arabic and Indic scripts belong to this
   389    category.
   390 
   391    Emacs display supports this by providing "character compositions",
   392    most of which is implemented in composite.c.  During the buffer
   393    scan that delivers characters to `PRODUCE_GLYPHS', if the next
   394    character to be delivered is a composed character, the iteration
   395    calls `composition_reseat_it' and `next_element_from_composition'.
   396    If they succeed to compose the character with one or more of the
   397    following characters, the whole sequence of characters that were
   398    composed is recorded in the `struct composition_it' object that is
   399    part of the buffer iterator.  The composed sequence could produce
   400    one or more font glyphs (called "grapheme clusters") on the screen.
   401    Each of these grapheme clusters is then delivered to
   402    `PRODUCE_GLYPHS' in the direction corresponding to the current bidi
   403    scan direction (recorded in the `scan_dir' member of the `struct
   404    bidi_it' object that is part of the iterator).  In particular, if
   405    the bidi iterator currently scans the buffer backwards, the
   406    grapheme clusters are delivered back to front.  This reorders the
   407    grapheme clusters as appropriate for the current bidi context.
   408    Note that this means that the grapheme clusters are always stored
   409    in the `LGSTRING' object (see composite.c) in the logical order.
   410 
   411    Moving an iterator in bidirectional text
   412    without producing glyphs.
   413 
   414    Note one important detail mentioned above: that the bidi reordering
   415    engine, driven by the iterator, produces characters in R2L rows
   416    starting at the character that will be the rightmost on display.
   417    As far as the iterator is concerned, the geometry of such rows is
   418    still left to right, i.e. the iterator "thinks" the first character
   419    is at the leftmost pixel position.  The iterator does not know that
   420    `PRODUCE_GLYPHS' reverses the order of the glyphs that the iterator
   421    delivers.  This is important when functions from the `move_it_*'
   422    family are used to get to certain screen position or to match
   423    screen coordinates with buffer coordinates: these functions use the
   424    iterator geometry, which is left to right even in R2L paragraphs.
   425    This works well with most callers of `move_it_*', because they need
   426    to get to a specific column, and columns are still numbered in the
   427    reading order, i.e. the rightmost character in a R2L paragraph is
   428    still column zero.  But some callers do not get well with this; a
   429    notable example is mouse clicks that need to find the character
   430    that corresponds to certain pixel coordinates.  See
   431    `buffer_posn_from_coords' in dispnew.c for how this is handled.  */
   432 
   433 #include <config.h>
   434 #include <stdlib.h>
   435 #include <limits.h>
   436 #include <math.h>
   437 
   438 #include "lisp.h"
   439 #include "atimer.h"
   440 #include "composite.h"
   441 #include "keyboard.h"
   442 #include "sysstdio.h"
   443 #include "systime.h"
   444 #include "frame.h"
   445 #include "window.h"
   446 #include "termchar.h"
   447 #include "dispextern.h"
   448 #include "character.h"
   449 #include "category.h"
   450 #include "buffer.h"
   451 #include "charset.h"
   452 #include "indent.h"
   453 #include "commands.h"
   454 #include "keymap.h"
   455 #include "disptab.h"
   456 #include "termhooks.h"
   457 #include "termopts.h"
   458 #include "intervals.h"
   459 #include "coding.h"
   460 #include "region-cache.h"
   461 #include "font.h"
   462 #include "fontset.h"
   463 #include "blockinput.h"
   464 #include "xwidget.h"
   465 #ifdef HAVE_WINDOW_SYSTEM
   466 #include TERM_HEADER
   467 #endif /* HAVE_WINDOW_SYSTEM */
   468 
   469 #ifndef FRAME_OUTPUT_DATA
   470 #define FRAME_OUTPUT_DATA(f) (NULL)
   471 #endif
   472 
   473 #define DISP_INFINITY 10000000
   474 
   475 /* Holds the list (error).  */
   476 static Lisp_Object list_of_error;
   477 
   478 #ifdef HAVE_WINDOW_SYSTEM
   479 
   480 /* Test if overflow newline into fringe.  Called with iterator IT
   481    at or past right window margin, and with IT->current_x set.  */
   482 
   483 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(IT)             \
   484   (!NILP (Voverflow_newline_into_fringe)                \
   485    && FRAME_WINDOW_P ((IT)->f)                          \
   486    && ((IT)->bidi_it.paragraph_dir == R2L               \
   487        ? (WINDOW_LEFT_FRINGE_WIDTH ((IT)->w) > 0)       \
   488        : (WINDOW_RIGHT_FRINGE_WIDTH ((IT)->w) > 0))     \
   489    && (IT)->current_x == (IT)->last_visible_x)
   490 
   491 #else /* !HAVE_WINDOW_SYSTEM */
   492 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) false
   493 #endif /* HAVE_WINDOW_SYSTEM */
   494 
   495 /* Test if the display element loaded in IT, or the underlying buffer
   496    or string character, is a space or a TAB character.  This is used
   497    to determine where word wrapping can occur.  */
   498 
   499 #define IT_DISPLAYING_WHITESPACE(it)                                    \
   500   ((it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))        \
   501    || ((STRINGP (it->string)                                            \
   502         && (SREF (it->string, IT_STRING_BYTEPOS (*it)) == ' '           \
   503             || SREF (it->string, IT_STRING_BYTEPOS (*it)) == '\t'))     \
   504        || (it->s                                                        \
   505            && (it->s[IT_BYTEPOS (*it)] == ' '                           \
   506                || it->s[IT_BYTEPOS (*it)] == '\t'))                     \
   507        || (IT_BYTEPOS (*it) < ZV_BYTE                                   \
   508            && (*BYTE_POS_ADDR (IT_BYTEPOS (*it)) == ' '                 \
   509                || *BYTE_POS_ADDR (IT_BYTEPOS (*it)) == '\t'))))
   510 
   511 /* These are the category sets we use.  They are defined by
   512    kinsoku.el and characters.el.  */
   513 #define NOT_AT_EOL '<'
   514 #define NOT_AT_BOL '>'
   515 #define LINE_BREAKABLE '|'
   516 
   517 static bool
   518 it_char_has_category(struct it *it, int cat)
   519 {
   520   int ch = 0;
   521   if (it->what == IT_CHARACTER)
   522     ch = it->c;
   523   else if (STRINGP (it->string))
   524     ch = SREF (it->string, IT_STRING_BYTEPOS (*it));
   525   else if (it->s)
   526     ch = it->s[IT_BYTEPOS (*it)];
   527   else if (IT_BYTEPOS (*it) < ZV_BYTE)
   528     ch = *BYTE_POS_ADDR (IT_BYTEPOS (*it));
   529 
   530   if (ch == 0)
   531     return false;
   532   else
   533     return CHAR_HAS_CATEGORY (ch, cat);
   534 }
   535 
   536 /* Return true if the current character allows wrapping before it.   */
   537 static bool
   538 char_can_wrap_before (struct it *it)
   539 {
   540   if (!word_wrap_by_category)
   541     return !IT_DISPLAYING_WHITESPACE (it);
   542 
   543   /* For CJK (LTR) text in RTL paragraph, EOL and BOL are flipped.
   544      Because in RTL paragraph, each glyph is prepended to the last
   545      one, effectively drawing right to left.  */
   546   int not_at_bol;
   547   if (it->glyph_row && it->glyph_row->reversed_p)
   548     not_at_bol = NOT_AT_EOL;
   549   else
   550     not_at_bol = NOT_AT_BOL;
   551   /* You cannot wrap before a space or tab because that way you'll
   552      have space and tab at the beginning of next line.  */
   553   return (!IT_DISPLAYING_WHITESPACE (it)
   554           /* Can be at BOL.  */
   555           && !it_char_has_category (it, not_at_bol));
   556 }
   557 
   558 /* Return true if the current character allows wrapping after it.   */
   559 static bool
   560 char_can_wrap_after (struct it *it)
   561 {
   562   if (!word_wrap_by_category)
   563     return IT_DISPLAYING_WHITESPACE (it);
   564 
   565   /* For CJK (LTR) text in RTL paragraph, EOL and BOL are flipped.
   566      Because in RTL paragraph, each glyph is prepended to the last
   567      one, effectively drawing right to left.  */
   568   int not_at_eol;
   569   if (it->glyph_row && it->glyph_row->reversed_p)
   570     not_at_eol = NOT_AT_BOL;
   571   else
   572     not_at_eol = NOT_AT_EOL;
   573 
   574   return (IT_DISPLAYING_WHITESPACE (it)
   575           /* Can break after && can be at EOL.  */
   576           || (it_char_has_category (it, LINE_BREAKABLE)
   577               && !it_char_has_category (it, not_at_eol)));
   578 }
   579 
   580 #undef IT_DISPLAYING_WHITESPACE
   581 #undef NOT_AT_EOL
   582 #undef NOT_AT_BOL
   583 #undef LINE_BREAKABLE
   584 
   585 /* If all the conditions needed to print the fill column indicator are
   586    met, return the (nonnegative) column number, else return a negative
   587    value.  */
   588 static int
   589 fill_column_indicator_column (struct it *it, int char_width)
   590 {
   591   if (display_fill_column_indicator
   592       && !it->w->pseudo_window_p
   593       && it->continuation_lines_width == 0
   594       && CHARACTERP (Vdisplay_fill_column_indicator_character))
   595     {
   596       Lisp_Object col = (EQ (Vdisplay_fill_column_indicator_column, Qt)
   597                          ? BVAR (current_buffer, fill_column)
   598                          : Vdisplay_fill_column_indicator_column);
   599 
   600       /* The stretch width needs to consider the latter
   601          added glyph in append_space_for_newline.  */
   602       if (RANGED_FIXNUMP (0, col, INT_MAX))
   603         {
   604           int icol = XFIXNUM (col);
   605           if (!ckd_mul (&icol, icol, char_width)
   606               && !ckd_add (&icol, icol, it->lnum_pixel_width))
   607             return icol;
   608         }
   609     }
   610   return -1;
   611 }
   612 
   613 /* True means print newline to stdout before next mini-buffer message.  */
   614 
   615 bool noninteractive_need_newline;
   616 
   617 /* True means print newline to message log before next message.  */
   618 
   619 static bool message_log_need_newline;
   620 
   621 /* Three markers that message_dolog uses.
   622    It could allocate them itself, but that causes trouble
   623    in handling memory-full errors.  */
   624 static Lisp_Object message_dolog_marker1;
   625 static Lisp_Object message_dolog_marker2;
   626 static Lisp_Object message_dolog_marker3;
   627 
   628 /* The buffer position of the first character appearing entirely or
   629    partially on the line of the selected window which contains the
   630    cursor; <= 0 if not known.  Set by set_cursor_from_row, used for
   631    redisplay optimization in redisplay_internal.  */
   632 
   633 static struct text_pos this_line_start_pos;
   634 
   635 /* Number of characters past the end of the line above, including the
   636    terminating newline.  */
   637 
   638 static struct text_pos this_line_end_pos;
   639 
   640 /* The vertical positions and the height of this line.  */
   641 
   642 static int this_line_vpos;
   643 static int this_line_y;
   644 static int this_line_pixel_height;
   645 
   646 /* X position at which this display line starts.  Usually zero;
   647    negative if first character is partially visible.  */
   648 
   649 static int this_line_start_x;
   650 
   651 /* The smallest character position seen by move_it_* functions as they
   652    move across display lines.  Used to set MATRIX_ROW_START_CHARPOS of
   653    hscrolled lines, see display_line.  */
   654 
   655 static struct text_pos this_line_min_pos;
   656 
   657 /* Buffer that this_line_.* variables are referring to.  */
   658 
   659 static struct buffer *this_line_buffer;
   660 
   661 /* True if an overlay arrow has been displayed in this window.  */
   662 
   663 static bool overlay_arrow_seen;
   664 
   665 /* Vector containing glyphs for an ellipsis `...'.  */
   666 
   667 static Lisp_Object default_invis_vector[3];
   668 
   669 /* This is the window where the echo area message was displayed.  It
   670    is always a mini-buffer window, but it may not be the same window
   671    currently active as a mini-buffer.  */
   672 
   673 Lisp_Object echo_area_window;
   674 
   675 /* Stack of messages, which are pushed by push_message and popped and
   676    displayed by restore_message.  */
   677 
   678 static Lisp_Object Vmessage_stack;
   679 
   680 /* True means multibyte characters were enabled when the echo area
   681    message was specified.  */
   682 
   683 static bool message_enable_multibyte;
   684 
   685 /* At each redisplay cycle, we should refresh everything there is to refresh.
   686    To do that efficiently, we use many optimizations that try to make sure we
   687    don't waste too much time updating things that haven't changed.
   688    The coarsest such optimization is that, in the most common cases, we only
   689    look at the selected-window.
   690 
   691    To know whether other windows should be considered for redisplay, we use the
   692    variable windows_or_buffers_changed: as long as it is 0, it means that we
   693    have not noticed anything that should require updating anything else than
   694    the selected-window.  If it is set to REDISPLAY_SOME, it means that since
   695    last redisplay, some changes have been made which could impact other
   696    windows.  To know which ones need redisplay, every buffer, window, and frame
   697    has a `redisplay' bit, which (if true) means that this object needs to be
   698    redisplayed.  If windows_or_buffers_changed is 0, we know there's no point
   699    looking for those `redisplay' bits (actually, there might be some such bits
   700    set, but then only on objects which aren't displayed anyway).
   701 
   702    OTOH if it's non-zero we will have to loop through all windows and then
   703    check the `redisplay' bit of the corresponding window, frame, and buffer, in
   704    order to decide whether that window needs attention or not.  Note that we
   705    can't just look at the frame's redisplay bit to decide that the whole frame
   706    can be skipped, since even if the frame's redisplay bit is unset, some of
   707    its windows's redisplay bits may be set.
   708 
   709    Mostly for historical reasons, windows_or_buffers_changed can also take
   710    other non-zero values.  In that case, the precise value doesn't matter (it
   711    encodes the cause of the setting but is only used for debugging purposes),
   712    and what it means is that we shouldn't pay attention to any `redisplay' bits
   713    and we should simply try and redisplay every window out there.  */
   714 
   715 int windows_or_buffers_changed;
   716 
   717 /* Nonzero if we should redraw the mode lines on the next redisplay.
   718    Similarly to `windows_or_buffers_changed', if it has value REDISPLAY_SOME,
   719    then only redisplay the mode lines in those buffers/windows/frames where the
   720    `redisplay' bit has been set.
   721    For any other value, redisplay all mode lines (the number used is then only
   722    used to track down the cause for this full-redisplay).
   723 
   724    Since the frame title uses the same %-constructs as the mode line
   725    (except %c, %C, and %l), if this variable is non-zero, we also consider
   726    redisplaying the title of each frame, see gui_consider_frame_title.
   727 
   728    The `redisplay' bits are the same as those used for
   729    windows_or_buffers_changed, and setting windows_or_buffers_changed also
   730    causes recomputation of the mode lines of all those windows.  IOW this
   731    variable only has an effect if windows_or_buffers_changed is zero, in which
   732    case we should only need to redisplay the mode-line of those objects with
   733    a `redisplay' bit set but not the window's text content (tho we may still
   734    need to refresh the text content of the selected-window).  */
   735 
   736 int update_mode_lines;
   737 
   738 /* True after display_mode_line if %l was used and it displayed a
   739    line number.  */
   740 
   741 static bool line_number_displayed;
   742 
   743 /* Current, index 0, and last displayed echo area message.  Either
   744    buffers from echo_buffers, or nil to indicate no message.  */
   745 
   746 Lisp_Object echo_area_buffer[2];
   747 
   748 /* The buffers referenced from echo_area_buffer.  */
   749 
   750 static Lisp_Object echo_buffer[2];
   751 
   752 /* A vector saved used in with_area_buffer to reduce consing.  */
   753 
   754 static Lisp_Object Vwith_echo_area_save_vector;
   755 
   756 /* True means display_echo_area should display the last echo area
   757    message again.  Set by redisplay_preserve_echo_area.  */
   758 
   759 static bool display_last_displayed_message_p;
   760 
   761 /* True if echo area is being used by print; false if being used by
   762    message.  */
   763 
   764 static bool message_buf_print;
   765 
   766 /* Set to true in clear_message to make redisplay_internal aware
   767    of an emptied echo area.  */
   768 
   769 static bool message_cleared_p;
   770 
   771 /* A scratch glyph row with contents used for generating truncation
   772    glyphs and overlay-arrow glyphs.  */
   773 
   774 #define MAX_SCRATCH_GLYPHS 100
   775 static struct glyph_row scratch_glyph_row;
   776 static struct glyph scratch_glyphs[MAX_SCRATCH_GLYPHS];
   777 
   778 /* Ascent and height of the last line processed by move_it_to.  */
   779 
   780 static int last_height;
   781 
   782 /* True if there's a help-echo in the echo area.  */
   783 
   784 bool help_echo_showing_p;
   785 
   786 /* The maximum distance to look ahead for text properties.  Values
   787    that are too small let us call compute_char_face and similar
   788    functions too often which is expensive.  Values that are too large
   789    let us call compute_char_face and alike too often because we
   790    might not be interested in text properties that far away.  */
   791 
   792 #define TEXT_PROP_DISTANCE_LIMIT 100
   793 
   794 /* SAVE_IT and RESTORE_IT are called when we save a snapshot of the
   795    iterator state and later restore it.  This is needed because the
   796    bidi iterator on bidi.c keeps a stacked cache of its states, which
   797    is really a singleton.  When we use scratch iterator objects to
   798    move around the buffer, we can cause the bidi cache to be pushed or
   799    popped, and therefore we need to restore the cache state when we
   800    return to the original iterator.  */
   801 #define SAVE_IT(ITCOPY, ITORIG, CACHE)          \
   802   do {                                          \
   803     if (CACHE)                                  \
   804       bidi_unshelve_cache (CACHE, true);        \
   805     ITCOPY = ITORIG;                            \
   806     CACHE = bidi_shelve_cache ();               \
   807   } while (false)
   808 
   809 #define RESTORE_IT(pITORIG, pITCOPY, CACHE)     \
   810   do {                                          \
   811     if (pITORIG != pITCOPY)                     \
   812       *(pITORIG) = *(pITCOPY);                  \
   813     bidi_unshelve_cache (CACHE, false);         \
   814     CACHE = NULL;                               \
   815   } while (false)
   816 
   817 /* Functions to mark elements as needing redisplay.  */
   818 enum { REDISPLAY_SOME = 2};     /* Arbitrary choice.  */
   819 
   820 static bool calc_pixel_width_or_height (double *, struct it *, Lisp_Object,
   821                                         struct font *, bool, int *);
   822 
   823 void
   824 redisplay_other_windows (void)
   825 {
   826   if (!windows_or_buffers_changed)
   827     windows_or_buffers_changed = REDISPLAY_SOME;
   828 }
   829 
   830 void
   831 wset_redisplay (struct window *w)
   832 {
   833   /* Beware: selected_window can be nil during early stages.  */
   834   if (!BASE_EQ (make_lisp_ptr (w, Lisp_Vectorlike), selected_window))
   835     redisplay_other_windows ();
   836   w->redisplay = true;
   837 }
   838 
   839 void
   840 fset_redisplay (struct frame *f)
   841 {
   842   redisplay_other_windows ();
   843   f->redisplay = true;
   844 }
   845 
   846 void
   847 bset_redisplay (struct buffer *b)
   848 {
   849   int count = buffer_window_count (b);
   850   if (count > 0)
   851     {
   852       /* ... it's visible in other window than selected,  */
   853       if (count > 1 || b != XBUFFER (XWINDOW (selected_window)->contents))
   854         redisplay_other_windows ();
   855       /* Even if we don't set windows_or_buffers_changed, do set `redisplay'
   856          so that if we later set windows_or_buffers_changed, this buffer will
   857          not be omitted.  */
   858       b->text->redisplay = true;
   859     }
   860 }
   861 
   862 void
   863 bset_update_mode_line (struct buffer *b)
   864 {
   865   if (!update_mode_lines)
   866     update_mode_lines = REDISPLAY_SOME;
   867   b->text->redisplay = true;
   868 }
   869 
   870 void
   871 wset_update_mode_line (struct window *w)
   872 {
   873   w->update_mode_line = true;
   874   /* When a window's mode line needs to be updated, the window's frame's
   875      title may also need to be updated, but we don't need to worry about it
   876      here.  Instead, `gui_consider_frame_title' is automatically called
   877      whenever w->update_mode_line is set for that frame's selected window.
   878      But for this to work reliably, we have to make sure the window
   879      is considered, so we have to mark it for redisplay.  */
   880   wset_redisplay (w);
   881 }
   882 
   883 DEFUN ("set-buffer-redisplay", Fset_buffer_redisplay,
   884        Sset_buffer_redisplay, 4, 4, 0,
   885        doc: /* Mark the current buffer for redisplay.
   886 This function may be passed to `add-variable-watcher'.  */)
   887   (Lisp_Object symbol, Lisp_Object newval, Lisp_Object op, Lisp_Object where)
   888 {
   889   bset_update_mode_line (current_buffer);
   890   current_buffer->prevent_redisplay_optimizations_p = true;
   891   return Qnil;
   892 }
   893 
   894 /* redisplay_trace is for displaying traces of redisplay.
   895    If Emacs was compiled with GLYPH_DEBUG defined, the variable
   896    trace_redisplay_p can be set to a non-zero value in debugging
   897    sessions to activate traces.  */
   898 #ifdef GLYPH_DEBUG
   899 extern bool trace_redisplay_p EXTERNALLY_VISIBLE;
   900 bool trace_redisplay_p;
   901 #else
   902 enum { trace_redisplay_p = false };
   903 #endif
   904 static void ATTRIBUTE_FORMAT_PRINTF (1, 2)
   905 redisplay_trace (char const *fmt, ...)
   906 {
   907   if (trace_redisplay_p)
   908     {
   909       va_list ap;
   910       va_start (ap, fmt);
   911       vprintf (fmt, ap);
   912       va_end (ap);
   913     }
   914 }
   915 
   916 #ifdef DEBUG_TRACE_MOVE
   917 extern bool trace_move EXTERNALLY_VISIBLE;
   918 bool trace_move;
   919 #else
   920 enum { trace_move = false };
   921 #endif
   922 static void ATTRIBUTE_FORMAT_PRINTF (1, 2)
   923 move_trace (char const *fmt, ...)
   924 {
   925   if (trace_move)
   926     {
   927       va_list ap;
   928       va_start (ap, fmt);
   929       vprintf (fmt, ap);
   930       va_end (ap);
   931     }
   932 }
   933 
   934 /* Buffer being redisplayed -- for redisplay_window_error.  */
   935 
   936 static struct buffer *displayed_buffer;
   937 
   938 /* Value returned from text property handlers (see below).  */
   939 
   940 enum prop_handled
   941 {
   942   HANDLED_NORMALLY,
   943   HANDLED_RECOMPUTE_PROPS,
   944   HANDLED_OVERLAY_STRING_CONSUMED,
   945   HANDLED_RETURN
   946 };
   947 
   948 /* A description of text properties that redisplay is interested
   949    in.  */
   950 
   951 struct props
   952 {
   953   /* The symbol index of the name of the property.  */
   954   short name;
   955 
   956   /* A unique index for the property.  */
   957   enum prop_idx idx;
   958 
   959   /* A handler function called to set up iterator IT from the property
   960      at IT's current position.  Value is used to steer handle_stop.  */
   961   enum prop_handled (*handler) (struct it *it);
   962 };
   963 
   964 static enum prop_handled handle_face_prop (struct it *);
   965 static enum prop_handled handle_invisible_prop (struct it *);
   966 static enum prop_handled handle_display_prop (struct it *);
   967 static enum prop_handled handle_composition_prop (struct it *);
   968 static enum prop_handled handle_overlay_change (struct it *);
   969 static enum prop_handled handle_fontified_prop (struct it *);
   970 
   971 /* Properties handled by iterators.  */
   972 
   973 static struct props it_props[] =
   974 {
   975   {SYMBOL_INDEX (Qfontified),   FONTIFIED_PROP_IDX,     handle_fontified_prop},
   976   /* Handle `face' before `display' because some sub-properties of
   977      `display' need to know the face.  */
   978   {SYMBOL_INDEX (Qface),        FACE_PROP_IDX,          handle_face_prop},
   979   {SYMBOL_INDEX (Qdisplay),     DISPLAY_PROP_IDX,       handle_display_prop},
   980   {SYMBOL_INDEX (Qinvisible),   INVISIBLE_PROP_IDX,     handle_invisible_prop},
   981   {SYMBOL_INDEX (Qcomposition), COMPOSITION_PROP_IDX, handle_composition_prop},
   982   {0,                           0,                      NULL}
   983 };
   984 
   985 /* Enumeration returned by some move_it_.* functions internally.  */
   986 
   987 enum move_it_result
   988 {
   989   /* Not used.  Undefined value.  */
   990   MOVE_UNDEFINED,
   991 
   992   /* Move ended at the requested buffer position or ZV.  */
   993   MOVE_POS_MATCH_OR_ZV,
   994 
   995   /* Move ended at the requested X pixel position.  */
   996   MOVE_X_REACHED,
   997 
   998   /* Move within a line ended at the end of a line that must be
   999      continued.  */
  1000   MOVE_LINE_CONTINUED,
  1001 
  1002   /* Move within a line ended at the end of a line that would
  1003      be displayed truncated.  */
  1004   MOVE_LINE_TRUNCATED,
  1005 
  1006   /* Move within a line ended at a line end.  */
  1007   MOVE_NEWLINE_OR_CR
  1008 };
  1009 
  1010 /* This counter is used to clear the face cache every once in a while
  1011    in redisplay_internal.  It is incremented for each redisplay.
  1012    Every CLEAR_FACE_CACHE_COUNT full redisplays, the face cache is
  1013    cleared.  */
  1014 
  1015 #define CLEAR_FACE_CACHE_COUNT  500
  1016 static int clear_face_cache_count;
  1017 
  1018 /* Similarly for the image cache.  */
  1019 
  1020 #ifdef HAVE_WINDOW_SYSTEM
  1021 #define CLEAR_IMAGE_CACHE_COUNT 101
  1022 static int clear_image_cache_count;
  1023 
  1024 /* Null glyph slice */
  1025 static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 };
  1026 #endif
  1027 
  1028 /* True while redisplay_internal is in progress.  */
  1029 
  1030 bool redisplaying_p;
  1031 
  1032 /* True while some display-engine code is working on layout of some
  1033    window.
  1034 
  1035    WARNING: Use sparingly, preferably only in top level of commands
  1036    and important functions, because using it in nested calls might
  1037    reset the flag when the inner call returns, behind the back of
  1038    the callers.  */
  1039 bool display_working_on_window_p;
  1040 
  1041 /* If a string, XTread_socket generates an event to display that string.
  1042    (The display is done in read_char.)  */
  1043 
  1044 Lisp_Object help_echo_string;
  1045 Lisp_Object help_echo_window;
  1046 Lisp_Object help_echo_object;
  1047 ptrdiff_t help_echo_pos;
  1048 
  1049 /* Temporary variable for XTread_socket.  */
  1050 
  1051 Lisp_Object previous_help_echo_string;
  1052 
  1053 /* Platform-independent portion of hourglass implementation.  */
  1054 
  1055 #ifdef HAVE_WINDOW_SYSTEM
  1056 
  1057 /* True means an hourglass cursor is currently shown.  */
  1058 static bool hourglass_shown_p;
  1059 
  1060 /* If non-null, an asynchronous timer that, when it expires, displays
  1061    an hourglass cursor on all frames.  */
  1062 static struct atimer *hourglass_atimer;
  1063 
  1064 #endif /* HAVE_WINDOW_SYSTEM */
  1065 
  1066 /* Default number of seconds to wait before displaying an hourglass
  1067    cursor.  */
  1068 #define DEFAULT_HOURGLASS_DELAY 1
  1069 
  1070 #ifdef HAVE_WINDOW_SYSTEM
  1071 
  1072 /* Default pixel width of `thin-space' display method.  */
  1073 #define THIN_SPACE_WIDTH 1
  1074 
  1075 #endif /* HAVE_WINDOW_SYSTEM */
  1076 
  1077 /* Function prototypes.  */
  1078 
  1079 static void setup_for_ellipsis (struct it *, int);
  1080 static void set_iterator_to_next (struct it *, bool);
  1081 static void mark_window_display_accurate_1 (struct window *, bool);
  1082 static bool row_for_charpos_p (struct glyph_row *, ptrdiff_t);
  1083 static bool cursor_row_p (struct glyph_row *);
  1084 static int redisplay_mode_lines (Lisp_Object, bool);
  1085 
  1086 static void handle_line_prefix (struct it *);
  1087 
  1088 static void handle_stop_backwards (struct it *, ptrdiff_t);
  1089 static void unwind_with_echo_area_buffer (Lisp_Object);
  1090 static Lisp_Object with_echo_area_buffer_unwind_data (struct window *);
  1091 static bool current_message_1 (void *, Lisp_Object);
  1092 static bool truncate_message_1 (void *, Lisp_Object);
  1093 static void set_message (Lisp_Object);
  1094 static bool set_message_1 (void *, Lisp_Object);
  1095 static bool display_echo_area_1 (void *, Lisp_Object);
  1096 static bool resize_mini_window_1 (void *, Lisp_Object);
  1097 static void unwind_redisplay (void);
  1098 static void extend_face_to_end_of_line (struct it *);
  1099 static intmax_t message_log_check_duplicate (ptrdiff_t, ptrdiff_t);
  1100 static void push_it (struct it *, struct text_pos *);
  1101 static void iterate_out_of_display_property (struct it *);
  1102 static void pop_it (struct it *);
  1103 static void redisplay_internal (void);
  1104 static void echo_area_display (bool);
  1105 static void block_buffer_flips (void);
  1106 static void unblock_buffer_flips (void);
  1107 static void redisplay_windows (Lisp_Object);
  1108 static void redisplay_window (Lisp_Object, bool);
  1109 static Lisp_Object redisplay_window_error (Lisp_Object);
  1110 static Lisp_Object redisplay_window_0 (Lisp_Object);
  1111 static Lisp_Object redisplay_window_1 (Lisp_Object);
  1112 static bool set_cursor_from_row (struct window *, struct glyph_row *,
  1113                                  struct glyph_matrix *, ptrdiff_t, ptrdiff_t,
  1114                                  int, int);
  1115 static bool cursor_row_fully_visible_p (struct window *, bool, bool, bool);
  1116 static bool update_menu_bar (struct frame *, bool, bool);
  1117 static bool try_window_reusing_current_matrix (struct window *);
  1118 static int try_window_id (struct window *);
  1119 static void maybe_produce_line_number (struct it *);
  1120 static bool should_produce_line_number (struct it *);
  1121 static bool display_line (struct it *, int);
  1122 static int display_mode_lines (struct window *);
  1123 static int display_mode_line (struct window *, enum face_id, Lisp_Object);
  1124 static int display_mode_element (struct it *, int, int, int, Lisp_Object,
  1125                                  Lisp_Object, bool);
  1126 static int store_mode_line_string (const char *, Lisp_Object, bool, int, int,
  1127                                    Lisp_Object);
  1128 static const char *decode_mode_spec (struct window *, int, int, Lisp_Object *);
  1129 static void display_menu_bar (struct window *);
  1130 static void display_tab_bar (struct window *);
  1131 static void update_tab_bar (struct frame *, bool);
  1132 static ptrdiff_t display_count_lines (ptrdiff_t, ptrdiff_t, ptrdiff_t,
  1133                                       ptrdiff_t *);
  1134 static void pint2str (register char *, register int, register ptrdiff_t);
  1135 
  1136 static int display_string (const char *, Lisp_Object, Lisp_Object,
  1137                            ptrdiff_t, ptrdiff_t, struct it *, int, int, int,
  1138                            int);
  1139 static void compute_line_metrics (struct it *);
  1140 static bool get_overlay_strings (struct it *, ptrdiff_t);
  1141 static bool get_overlay_strings_1 (struct it *, ptrdiff_t, bool);
  1142 static void next_overlay_string (struct it *);
  1143 static void reseat (struct it *, struct text_pos, bool);
  1144 static void reseat_1 (struct it *, struct text_pos, bool);
  1145 static bool next_element_from_display_vector (struct it *);
  1146 static bool next_element_from_string (struct it *);
  1147 static bool next_element_from_c_string (struct it *);
  1148 static bool next_element_from_buffer (struct it *);
  1149 static bool next_element_from_composition (struct it *);
  1150 static bool next_element_from_image (struct it *);
  1151 static bool next_element_from_stretch (struct it *);
  1152 static bool next_element_from_xwidget (struct it *);
  1153 static void load_overlay_strings (struct it *, ptrdiff_t);
  1154 static bool get_next_display_element (struct it *);
  1155 static enum move_it_result
  1156        move_it_in_display_line_to (struct it *, ptrdiff_t, int,
  1157                                    enum move_operation_enum);
  1158 static void get_visually_first_element (struct it *);
  1159 static void compute_stop_pos (struct it *);
  1160 static int face_before_or_after_it_pos (struct it *, bool);
  1161 static int handle_display_spec (struct it *, Lisp_Object, Lisp_Object,
  1162                                 Lisp_Object, struct text_pos *, ptrdiff_t, bool);
  1163 static int handle_single_display_spec (struct it *, Lisp_Object, Lisp_Object,
  1164                                        Lisp_Object, struct text_pos *,
  1165                                        ptrdiff_t, int, bool, bool);
  1166 static int underlying_face_id (const struct it *);
  1167 
  1168 #define face_before_it_pos(IT) face_before_or_after_it_pos (IT, true)
  1169 #define face_after_it_pos(IT)  face_before_or_after_it_pos (IT, false)
  1170 
  1171 #ifdef HAVE_WINDOW_SYSTEM
  1172 
  1173 static void update_tool_bar (struct frame *, bool);
  1174 static void gui_draw_bottom_divider (struct window *w);
  1175 static void notice_overwritten_cursor (struct window *,
  1176                                        enum glyph_row_area,
  1177                                        int, int, int, int);
  1178 static int  normal_char_height (struct font *, int);
  1179 static void normal_char_ascent_descent (struct font *, int, int *, int *);
  1180 
  1181 static void append_stretch_glyph (struct it *, Lisp_Object,
  1182                                   int, int, int);
  1183 
  1184 static Lisp_Object get_it_property (struct it *, Lisp_Object);
  1185 static Lisp_Object calc_line_height_property (struct it *, Lisp_Object,
  1186                                               struct font *, int, bool);
  1187 static int adjust_glyph_width_for_mouse_face (struct glyph *,
  1188                                               struct glyph_row *,
  1189                                               struct window *, struct face *,
  1190                                               struct face *);
  1191 static void get_cursor_offset_for_mouse_face (struct window *w,
  1192                                               struct glyph_row *row,
  1193                                               int *offset);
  1194 #endif /* HAVE_WINDOW_SYSTEM */
  1195 
  1196 static void produce_special_glyphs (struct it *, enum display_element_type);
  1197 static void pad_mode_line (struct it *, bool);
  1198 static void show_mouse_face (Mouse_HLInfo *, enum draw_glyphs_face);
  1199 static bool coords_in_mouse_face_p (struct window *, int, int);
  1200 static void reset_box_start_end_flags (struct it *);
  1201 
  1202 
  1203 
  1204 /***********************************************************************
  1205                       Window display dimensions
  1206  ***********************************************************************/
  1207 
  1208 /* Return the bottom boundary y-position for text lines in window W.
  1209    This is the first y position at which a line cannot start.
  1210    It is relative to the top of the window.
  1211 
  1212    This is the height of W minus the height of a mode line, if any.  */
  1213 
  1214 int
  1215 window_text_bottom_y (struct window *w)
  1216 {
  1217   int height = WINDOW_PIXEL_HEIGHT (w);
  1218 
  1219   height -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  1220 
  1221   if (window_wants_mode_line (w))
  1222     height -= CURRENT_MODE_LINE_HEIGHT (w);
  1223 
  1224   height -= WINDOW_SCROLL_BAR_AREA_HEIGHT (w);
  1225 
  1226   return height;
  1227 }
  1228 
  1229 /* Return the pixel width of display area AREA of window W.
  1230    ANY_AREA means return the total width of W, not including
  1231    fringes to the left and right of the window.  */
  1232 
  1233 int
  1234 window_box_width (struct window *w, enum glyph_row_area area)
  1235 {
  1236   int width = w->pixel_width;
  1237 
  1238   if (!w->pseudo_window_p)
  1239     {
  1240       width -= WINDOW_SCROLL_BAR_AREA_WIDTH (w);
  1241       width -= WINDOW_RIGHT_DIVIDER_WIDTH (w);
  1242 
  1243       if (area == TEXT_AREA)
  1244         width -= (WINDOW_MARGINS_WIDTH (w)
  1245                    + WINDOW_FRINGES_WIDTH (w));
  1246       else if (area == LEFT_MARGIN_AREA)
  1247         width = WINDOW_LEFT_MARGIN_WIDTH (w);
  1248       else if (area == RIGHT_MARGIN_AREA)
  1249         width = WINDOW_RIGHT_MARGIN_WIDTH (w);
  1250     }
  1251 
  1252   /* With wide margins, fringes, etc. we might end up with a negative
  1253      width, correct that here.  */
  1254   return max (0, width);
  1255 }
  1256 
  1257 
  1258 /* Return the pixel height of the display area of window W, not
  1259    including mode lines of W, if any.  */
  1260 
  1261 int
  1262 window_box_height (struct window *w)
  1263 {
  1264   struct frame *f = XFRAME (w->frame);
  1265   int height = WINDOW_PIXEL_HEIGHT (w);
  1266 
  1267   eassert (height >= 0);
  1268 
  1269   height -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  1270   height -= WINDOW_SCROLL_BAR_AREA_HEIGHT (w);
  1271 
  1272   /* Note: the code below that determines the mode-line/header-line/tab-line
  1273      height is essentially the same as that contained in the macro
  1274      CURRENT_{MODE,HEADER,TAB}_LINE_HEIGHT, except that it checks whether
  1275      the appropriate glyph row has its `mode_line_p' flag set, and if
  1276      it doesn't, uses estimate_mode_line_height instead.  */
  1277 
  1278   if (window_wants_mode_line (w))
  1279     {
  1280       if (w->mode_line_height >= 0)
  1281         height -= w->mode_line_height;
  1282       else
  1283         {
  1284           struct glyph_row *ml_row
  1285             = (w->current_matrix && w->current_matrix->rows
  1286                ? MATRIX_MODE_LINE_ROW (w->current_matrix)
  1287                : 0);
  1288           if (ml_row && ml_row->mode_line_p)
  1289             height -= ml_row->height;
  1290           else
  1291             height -= estimate_mode_line_height
  1292               (f, CURRENT_MODE_LINE_ACTIVE_FACE_ID (w));
  1293         }
  1294     }
  1295 
  1296   if (window_wants_tab_line (w))
  1297     {
  1298       if (w->tab_line_height >= 0)
  1299         height -= w->tab_line_height;
  1300       else
  1301         {
  1302           struct glyph_row *tl_row
  1303             = (w->current_matrix && w->current_matrix->rows
  1304                ? MATRIX_TAB_LINE_ROW (w->current_matrix)
  1305                : 0);
  1306           if (tl_row && tl_row->mode_line_p)
  1307             height -= tl_row->height;
  1308           else
  1309             height -= estimate_mode_line_height (f, TAB_LINE_FACE_ID);
  1310         }
  1311     }
  1312 
  1313   if (window_wants_header_line (w))
  1314     {
  1315       if (w->header_line_height >= 0)
  1316         height -= w->header_line_height;
  1317       else
  1318         {
  1319           struct glyph_row *hl_row
  1320             = (w->current_matrix && w->current_matrix->rows
  1321                ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
  1322                : 0);
  1323           if (hl_row && hl_row->mode_line_p)
  1324             height -= hl_row->height;
  1325           else
  1326             height -= estimate_mode_line_height (f, HEADER_LINE_FACE_ID);
  1327         }
  1328     }
  1329 
  1330   /* With a very small font and a mode-line that's taller than
  1331      default, we might end up with a negative height.  */
  1332   return max (0, height);
  1333 }
  1334 
  1335 /* Return the window-relative coordinate of the left edge of display
  1336    area AREA of window W.  ANY_AREA means return the left edge of the
  1337    whole window, to the right of the left fringe of W.  */
  1338 
  1339 int
  1340 window_box_left_offset (struct window *w, enum glyph_row_area area)
  1341 {
  1342   int x;
  1343 
  1344   if (w->pseudo_window_p)
  1345     return 0;
  1346 
  1347   x = WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
  1348 
  1349   if (area == TEXT_AREA)
  1350     x += (WINDOW_LEFT_FRINGE_WIDTH (w)
  1351           + window_box_width (w, LEFT_MARGIN_AREA));
  1352   else if (area == RIGHT_MARGIN_AREA)
  1353     x += (WINDOW_LEFT_FRINGE_WIDTH (w)
  1354           + window_box_width (w, LEFT_MARGIN_AREA)
  1355           + window_box_width (w, TEXT_AREA)
  1356           + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  1357              ? 0
  1358              : WINDOW_RIGHT_FRINGE_WIDTH (w)));
  1359   else if (area == LEFT_MARGIN_AREA
  1360            && WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w))
  1361     x += WINDOW_LEFT_FRINGE_WIDTH (w);
  1362 
  1363   /* Don't return more than the window's pixel width.  */
  1364   return min (x, w->pixel_width);
  1365 }
  1366 
  1367 
  1368 /* Return the window-relative coordinate of the right edge of display
  1369    area AREA of window W.  ANY_AREA means return the right edge of the
  1370    whole window, to the left of the right fringe of W.  */
  1371 
  1372 static int
  1373 window_box_right_offset (struct window *w, enum glyph_row_area area)
  1374 {
  1375   /* Don't return more than the window's pixel width.  */
  1376   return min (window_box_left_offset (w, area) + window_box_width (w, area),
  1377               w->pixel_width);
  1378 }
  1379 
  1380 /* Return the frame-relative coordinate of the left edge of display
  1381    area AREA of window W.  ANY_AREA means return the left edge of the
  1382    whole window, to the right of the left fringe of W.  */
  1383 
  1384 int
  1385 window_box_left (struct window *w, enum glyph_row_area area)
  1386 {
  1387   struct frame *f = XFRAME (w->frame);
  1388   int x;
  1389 
  1390   if (w->pseudo_window_p)
  1391     return FRAME_INTERNAL_BORDER_WIDTH (f);
  1392 
  1393   x = (WINDOW_LEFT_EDGE_X (w)
  1394        + window_box_left_offset (w, area));
  1395 
  1396   return x;
  1397 }
  1398 
  1399 
  1400 /* Return the frame-relative coordinate of the right edge of display
  1401    area AREA of window W.  ANY_AREA means return the right edge of the
  1402    whole window, to the left of the right fringe of W.  */
  1403 
  1404 int
  1405 window_box_right (struct window *w, enum glyph_row_area area)
  1406 {
  1407   return window_box_left (w, area) + window_box_width (w, area);
  1408 }
  1409 
  1410 /* Get the bounding box of the display area AREA of window W, without
  1411    mode lines, in frame-relative coordinates.  ANY_AREA means the
  1412    whole window, not including the left and right fringes of
  1413    the window.  Return in *BOX_X and *BOX_Y the frame-relative pixel
  1414    coordinates of the upper-left corner of the box.  Return in
  1415    *BOX_WIDTH, and *BOX_HEIGHT the pixel width and height of the box.  */
  1416 
  1417 void
  1418 window_box (struct window *w, enum glyph_row_area area, int *box_x,
  1419             int *box_y, int *box_width, int *box_height)
  1420 {
  1421   if (box_width)
  1422     *box_width = window_box_width (w, area);
  1423   if (box_height)
  1424     *box_height = window_box_height (w);
  1425   if (box_x)
  1426     *box_x = window_box_left (w, area);
  1427   if (box_y)
  1428     {
  1429       *box_y = WINDOW_TOP_EDGE_Y (w);
  1430       if (window_wants_tab_line (w))
  1431         *box_y += CURRENT_TAB_LINE_HEIGHT (w);
  1432       if (window_wants_header_line (w))
  1433         *box_y += CURRENT_HEADER_LINE_HEIGHT (w);
  1434     }
  1435 }
  1436 
  1437 #ifdef HAVE_WINDOW_SYSTEM
  1438 
  1439 /* Get the bounding box of the display area AREA of window W, without
  1440    mode lines and both fringes of the window.  Return in *TOP_LEFT_X
  1441    and TOP_LEFT_Y the frame-relative pixel coordinates of the
  1442    upper-left corner of the box.  Return in *BOTTOM_RIGHT_X, and
  1443    *BOTTOM_RIGHT_Y the coordinates of the bottom-right corner of the
  1444    box.  */
  1445 
  1446 static void
  1447 window_box_edges (struct window *w, int *top_left_x, int *top_left_y,
  1448                   int *bottom_right_x, int *bottom_right_y)
  1449 {
  1450   window_box (w, ANY_AREA, top_left_x, top_left_y,
  1451               bottom_right_x, bottom_right_y);
  1452   *bottom_right_x += *top_left_x;
  1453   *bottom_right_y += *top_left_y;
  1454 }
  1455 
  1456 #endif /* HAVE_WINDOW_SYSTEM */
  1457 
  1458 /***********************************************************************
  1459                               Utilities
  1460  ***********************************************************************/
  1461 
  1462 /* Return the bottom y-position of the line the iterator IT is in.
  1463    This can modify IT's settings.  */
  1464 
  1465 int
  1466 line_bottom_y (struct it *it)
  1467 {
  1468   int line_height = it->max_ascent + it->max_descent;
  1469   int line_top_y = it->current_y;
  1470 
  1471   if (line_height == 0)
  1472     {
  1473       if (last_height)
  1474         line_height = last_height;
  1475       else if (IT_CHARPOS (*it) < ZV)
  1476         {
  1477           move_it_by_lines (it, 1);
  1478           line_height = (it->max_ascent || it->max_descent
  1479                          ? it->max_ascent + it->max_descent
  1480                          : last_height);
  1481         }
  1482       else
  1483         {
  1484           struct glyph_row *row = it->glyph_row;
  1485 
  1486           /* Use the default character height.  */
  1487           it->glyph_row = NULL;
  1488           it->what = IT_CHARACTER;
  1489           it->c = ' ';
  1490           it->len = 1;
  1491           PRODUCE_GLYPHS (it);
  1492           line_height = it->ascent + it->descent;
  1493           it->glyph_row = row;
  1494         }
  1495     }
  1496 
  1497   return line_top_y + line_height;
  1498 }
  1499 
  1500 DEFUN ("line-pixel-height", Fline_pixel_height,
  1501        Sline_pixel_height, 0, 0, 0,
  1502        doc: /* Return height in pixels of text line in the selected window.
  1503 
  1504 Value is the height in pixels of the line at point.  */)
  1505   (void)
  1506 {
  1507   struct it it;
  1508   struct text_pos pt;
  1509   struct window *w = XWINDOW (selected_window);
  1510   struct buffer *old_buffer = NULL;
  1511   Lisp_Object result;
  1512 
  1513   if (XBUFFER (w->contents) != current_buffer)
  1514     {
  1515       old_buffer = current_buffer;
  1516       set_buffer_internal_1 (XBUFFER (w->contents));
  1517     }
  1518   SET_TEXT_POS (pt, PT, PT_BYTE);
  1519   void *itdata = bidi_shelve_cache ();
  1520   start_display (&it, w, pt);
  1521   /* Start from the beginning of the screen line, to make sure we
  1522      traverse all of its display elements, and thus capture the
  1523      correct metrics.  */
  1524   move_it_by_lines (&it, 0);
  1525   it.vpos = it.current_y = 0;
  1526   last_height = 0;
  1527   result = make_fixnum (line_bottom_y (&it));
  1528   if (old_buffer)
  1529     set_buffer_internal_1 (old_buffer);
  1530 
  1531   bidi_unshelve_cache (itdata, false);
  1532   return result;
  1533 }
  1534 
  1535 /* Return the default pixel height of text lines in window W.  The
  1536    value is the canonical height of the W frame's default font, plus
  1537    any extra space required by the line-spacing variable or frame
  1538    parameter.
  1539 
  1540    Implementation note: this ignores any line-spacing text properties
  1541    put on the newline characters.  This is because those properties
  1542    only affect the _screen_ line ending in the newline (i.e., in a
  1543    continued line, only the last screen line will be affected), which
  1544    means only a small number of lines in a buffer can ever use this
  1545    feature.  Since this function is used to compute the default pixel
  1546    equivalent of text lines in a window, we can safely ignore those
  1547    few lines.  For the same reasons, we ignore the line-height
  1548    properties.  */
  1549 int
  1550 default_line_pixel_height (struct window *w)
  1551 {
  1552   struct frame *f = WINDOW_XFRAME (w);
  1553   int height = FRAME_LINE_HEIGHT (f);
  1554 
  1555   if (!FRAME_INITIAL_P (f) && BUFFERP (w->contents))
  1556     {
  1557       struct buffer *b = XBUFFER (w->contents);
  1558       Lisp_Object val = BVAR (b, extra_line_spacing);
  1559 
  1560       if (NILP (val))
  1561         val = BVAR (&buffer_defaults, extra_line_spacing);
  1562       if (!NILP (val))
  1563         {
  1564           if (RANGED_FIXNUMP (0, val, INT_MAX))
  1565             height += XFIXNAT (val);
  1566           else if (FLOATP (val))
  1567             {
  1568               int addon = XFLOAT_DATA (val) * height + 0.5;
  1569 
  1570               if (addon >= 0)
  1571                 height += addon;
  1572             }
  1573         }
  1574       else
  1575         height += f->extra_line_spacing;
  1576     }
  1577 
  1578   return height;
  1579 }
  1580 
  1581 /* Subroutine of pos_visible_p below.  Extracts a display string, if
  1582    any, from the display spec given as its argument.  */
  1583 static Lisp_Object
  1584 string_from_display_spec (Lisp_Object spec)
  1585 {
  1586   if (VECTORP (spec))
  1587     {
  1588       for (ptrdiff_t i = 0; i < ASIZE (spec); i++)
  1589         if (STRINGP (AREF (spec, i)))
  1590           return AREF (spec, i);
  1591     }
  1592   else
  1593     {
  1594       for (; CONSP (spec); spec = XCDR (spec))
  1595         if (STRINGP (XCAR (spec)))
  1596           return XCAR (spec);
  1597     }
  1598   return spec;
  1599 }
  1600 
  1601 
  1602 /* Limit insanely large values of W->hscroll on frame F to the largest
  1603    value that will still prevent first_visible_x and last_visible_x of
  1604    'struct it' from overflowing an int.  */
  1605 static int
  1606 window_hscroll_limited (struct window *w, struct frame *f)
  1607 {
  1608   ptrdiff_t window_hscroll = w->hscroll;
  1609   int window_text_width = window_box_width (w, TEXT_AREA);
  1610   int colwidth = FRAME_COLUMN_WIDTH (f);
  1611 
  1612   if (window_hscroll > (INT_MAX - window_text_width) / colwidth - 1)
  1613     window_hscroll = (INT_MAX - window_text_width) / colwidth - 1;
  1614 
  1615   return window_hscroll;
  1616 }
  1617 
  1618 /* Reset the box-face start and end flags in the iterator.  This is
  1619    called after producing glyphs, such that we reset these flags only
  1620    after producing a glyph with the flag set.  */
  1621 
  1622 static void
  1623 reset_box_start_end_flags (struct it *it)
  1624 {
  1625   /* Don't reset if we've drawn the glyph in the display margins --
  1626      those don't count as "produced glyphs".  */
  1627   if (it->area == TEXT_AREA
  1628       /* Don't reset if we displayed a fringe bitmap.  */
  1629       && !(it->what == IT_IMAGE && it->image_id < 0))
  1630     {
  1631       /* Don't reset if the face is not a box face: that might mean we
  1632          are iterating some overlay or display string, and the first
  1633          character to have the box face is yet to be seen, when we pop
  1634          the iterator stack. */
  1635       if (it->face_box_p)
  1636         it->start_of_box_run_p = false;
  1637       it->end_of_box_run_p = false;
  1638     }
  1639 }
  1640 
  1641 /* Return true if position CHARPOS is visible in window W.
  1642    CHARPOS < 0 means return info about WINDOW_END position.
  1643    If visible, set *X and *Y to pixel coordinates of top left corner.
  1644    Set *RTOP and *RBOT to pixel height of an invisible area of glyph at POS.
  1645    Set *ROWH and *VPOS to row's visible height and VPOS (row number).  */
  1646 
  1647 bool
  1648 pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
  1649                int *rtop, int *rbot, int *rowh, int *vpos)
  1650 {
  1651   struct it it;
  1652   void *itdata = bidi_shelve_cache ();
  1653   struct text_pos top;
  1654   bool visible_p = false;
  1655   struct buffer *old_buffer = NULL;
  1656   bool r2l = false;
  1657 
  1658   if (FRAME_INITIAL_P (XFRAME (WINDOW_FRAME (w))))
  1659     return visible_p;
  1660 
  1661   if (XBUFFER (w->contents) != current_buffer)
  1662     {
  1663       old_buffer = current_buffer;
  1664       set_buffer_internal_1 (XBUFFER (w->contents));
  1665     }
  1666 
  1667   SET_TEXT_POS_FROM_MARKER (top, w->start);
  1668   /* Scrolling a minibuffer window via scroll bar when the echo area
  1669      shows long text sometimes resets the minibuffer contents behind
  1670      our backs.  Also, someone might narrow-to-region and immediately
  1671      call a scroll function.  */
  1672   if (CHARPOS (top) > ZV || CHARPOS (top) < BEGV)
  1673     SET_TEXT_POS (top, BEGV, BEGV_BYTE);
  1674 
  1675   /* If the top of the window is after CHARPOS, the latter is surely
  1676      not visible.  */
  1677   if (charpos >= 0 && CHARPOS (top) > charpos)
  1678     return visible_p;
  1679 
  1680   /* Some Lisp hook could call us in the middle of redisplaying this
  1681      very window.  If, by some bad luck, we are retrying redisplay
  1682      because we found that the mode-line height and/or tab/header-line
  1683      height needs to be updated, the assignment of mode_line_height
  1684      and header_line_height below could disrupt that, due to the
  1685      selected/nonselected window dance during mode-line display, and
  1686      we could infloop.  Avoid that.  */
  1687   int prev_mode_line_height = w->mode_line_height;
  1688   int prev_header_line_height = w->header_line_height;
  1689   int prev_tab_line_height = w->tab_line_height;
  1690   /* Compute exact mode line heights.  */
  1691   if (window_wants_mode_line (w))
  1692     {
  1693       Lisp_Object window_mode_line_format
  1694         = window_parameter (w, Qmode_line_format);
  1695 
  1696       w->mode_line_height
  1697         = display_mode_line (w, CURRENT_MODE_LINE_ACTIVE_FACE_ID (w),
  1698                              NILP (window_mode_line_format)
  1699                              ? BVAR (current_buffer, mode_line_format)
  1700                              : window_mode_line_format);
  1701     }
  1702 
  1703   if (window_wants_tab_line (w))
  1704     {
  1705       Lisp_Object window_tab_line_format
  1706         = window_parameter (w, Qtab_line_format);
  1707 
  1708       w->tab_line_height
  1709         = display_mode_line (w, TAB_LINE_FACE_ID,
  1710                              NILP (window_tab_line_format)
  1711                              ? BVAR (current_buffer, tab_line_format)
  1712                              : window_tab_line_format);
  1713     }
  1714 
  1715   if (window_wants_header_line (w))
  1716     {
  1717       Lisp_Object window_header_line_format
  1718         = window_parameter (w, Qheader_line_format);
  1719 
  1720       w->header_line_height
  1721         = display_mode_line (w, HEADER_LINE_FACE_ID,
  1722                              NILP (window_header_line_format)
  1723                              ? BVAR (current_buffer, header_line_format)
  1724                              : window_header_line_format);
  1725     }
  1726 
  1727   start_display (&it, w, top);
  1728   move_it_to (&it, charpos, -1, it.last_visible_y - 1, -1,
  1729               (charpos >= 0 ? MOVE_TO_POS : 0) | MOVE_TO_Y);
  1730 
  1731   /* Adjust for line numbers, if CHARPOS is at or beyond first_visible_x,
  1732      but we didn't yet produce the line-number glyphs.  */
  1733   if (!NILP (Vdisplay_line_numbers)
  1734       && it.current_x >= it.first_visible_x
  1735       && IT_CHARPOS (it) == charpos
  1736       && !it.line_number_produced_p)
  1737     {
  1738       /* If the pixel width of line numbers was not yet known, compute
  1739          it now.  This usually happens in the first display line of a
  1740          window.  */
  1741       if (!it.lnum_pixel_width)
  1742         {
  1743           struct it it2;
  1744           void *it2data = NULL;
  1745 
  1746           SAVE_IT (it2, it, it2data);
  1747           move_it_by_lines (&it, 1);
  1748           it2.lnum_pixel_width = it.lnum_pixel_width;
  1749           RESTORE_IT (&it, &it2, it2data);
  1750         }
  1751       it.current_x += it.lnum_pixel_width;
  1752     }
  1753 
  1754   if (charpos >= 0
  1755       && (((!it.bidi_p || it.bidi_it.scan_dir != -1)
  1756            && IT_CHARPOS (it) >= charpos)
  1757           /* When scanning backwards under bidi iteration, move_it_to
  1758              stops at or _before_ CHARPOS, because it stops at or to
  1759              the _right_ of the character at CHARPOS.  */
  1760           || (it.bidi_p && it.bidi_it.scan_dir == -1
  1761               && IT_CHARPOS (it) <= charpos)))
  1762     {
  1763       /* We have reached CHARPOS, or passed it.  How the call to
  1764          move_it_to can overshoot: (i) If CHARPOS is on invisible text
  1765          or covered by a display property, move_it_to stops at the end
  1766          of the invisible text, to the right of CHARPOS.  (ii) If
  1767          CHARPOS is in a display vector, move_it_to stops on its last
  1768          glyph.  */
  1769       int top_x = it.current_x;
  1770       int top_y = it.current_y;
  1771       int window_top_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
  1772       int bottom_y;
  1773       struct it save_it;
  1774       void *save_it_data = NULL;
  1775 
  1776       /* Calling line_bottom_y may change it.method, it.position, etc.  */
  1777       SAVE_IT (save_it, it, save_it_data);
  1778       last_height = 0;
  1779       bottom_y = line_bottom_y (&it);
  1780       if (top_y < window_top_y)
  1781         visible_p = bottom_y > window_top_y;
  1782       else if (top_y < it.last_visible_y)
  1783         visible_p = true;
  1784       if (bottom_y >= it.last_visible_y
  1785           && it.bidi_p && it.bidi_it.scan_dir == -1
  1786           && IT_CHARPOS (it) < charpos)
  1787         {
  1788           /* When the last line of the window is scanned backwards
  1789              under bidi iteration, we could be duped into thinking
  1790              that we have passed CHARPOS, when in fact move_it_to
  1791              simply stopped short of CHARPOS because it reached
  1792              last_visible_y.  To see if that's what happened, we call
  1793              move_it_to again with a slightly larger vertical limit,
  1794              and see if it actually moved vertically; if it did, we
  1795              didn't really reach CHARPOS, which is beyond window end.  */
  1796           /* Why 10? because we don't know how many canonical lines
  1797              will the height of the next line(s) be.  So we guess.  */
  1798           int ten_more_lines = 10 * default_line_pixel_height (w);
  1799 
  1800           move_it_to (&it, charpos, -1, bottom_y + ten_more_lines, -1,
  1801                       MOVE_TO_POS | MOVE_TO_Y);
  1802           if (it.current_y > top_y)
  1803             visible_p = false;
  1804 
  1805         }
  1806       RESTORE_IT (&it, &save_it, save_it_data);
  1807       if (visible_p)
  1808         {
  1809           if (it.method == GET_FROM_DISPLAY_VECTOR)
  1810             {
  1811               /* We stopped on the last glyph of a display vector.
  1812                  Try and recompute.  Hack alert!  */
  1813               if (charpos < 2 || top.charpos >= charpos)
  1814                 top_x = it.glyph_row->x;
  1815               else
  1816                 {
  1817                   struct it it2, it2_prev;
  1818                   /* The idea is to get to the previous buffer
  1819                      position, consume the character there, and use
  1820                      the pixel coordinates we get after that.  But if
  1821                      the previous buffer position is also displayed
  1822                      from a display vector, we need to consume all of
  1823                      the glyphs from that display vector.  */
  1824                   start_display (&it2, w, top);
  1825                   it2.glyph_row = NULL;
  1826                   move_it_to (&it2, charpos - 1, -1, -1, -1, MOVE_TO_POS);
  1827                   /* If we didn't get to CHARPOS - 1, there's some
  1828                      replacing display property at that position, and
  1829                      we stopped after it.  That is exactly the place
  1830                      whose coordinates we want.  */
  1831                   if (IT_CHARPOS (it2) != charpos - 1)
  1832                     it2_prev = it2;
  1833                   else
  1834                     {
  1835                       /* Iterate until we get out of the display
  1836                          vector that displays the character at
  1837                          CHARPOS - 1.  */
  1838                       do {
  1839                         get_next_display_element (&it2);
  1840                         PRODUCE_GLYPHS (&it2);
  1841                         it2_prev = it2;
  1842                         set_iterator_to_next (&it2, true);
  1843                       } while (it2.method == GET_FROM_DISPLAY_VECTOR
  1844                                && IT_CHARPOS (it2) < charpos);
  1845                     }
  1846                   if (ITERATOR_AT_END_OF_LINE_P (&it2_prev)
  1847                       || it2_prev.current_x > it2_prev.last_visible_x)
  1848                     top_x = it.glyph_row->x;
  1849                   else
  1850                     {
  1851                       top_x = it2_prev.current_x;
  1852                       top_y = it2_prev.current_y;
  1853                     }
  1854                 }
  1855             }
  1856           else if (IT_CHARPOS (it) != charpos)
  1857             {
  1858               Lisp_Object cpos = make_fixnum (charpos);
  1859               Lisp_Object spec = Fget_char_property (cpos, Qdisplay, Qnil);
  1860               Lisp_Object string = string_from_display_spec (spec);
  1861               struct text_pos tpos;
  1862               bool newline_in_string
  1863                 = (STRINGP (string)
  1864                    && memchr (SDATA (string), '\n', SBYTES (string)));
  1865 
  1866               SET_TEXT_POS (tpos, charpos, CHAR_TO_BYTE (charpos));
  1867               bool replacing_spec_p
  1868                 = (!NILP (spec)
  1869                    && handle_display_spec (NULL, spec, Qnil, Qnil, &tpos,
  1870                                            charpos, FRAME_WINDOW_P (it.f)));
  1871               /* The tricky code below is needed because there's a
  1872                  discrepancy between move_it_to and how we set cursor
  1873                  when PT is at the beginning of a portion of text
  1874                  covered by a display property or an overlay with a
  1875                  display property, or the display line ends in a
  1876                  newline from a display string.  move_it_to will stop
  1877                  _after_ such display strings, whereas
  1878                  set_cursor_from_row conspires with cursor_row_p to
  1879                  place the cursor on the first glyph produced from the
  1880                  display string.  */
  1881 
  1882               /* We have overshoot PT because it is covered by a
  1883                  display property that replaces the text it covers.
  1884                  If the string includes embedded newlines, we are also
  1885                  in the wrong display line.  Backtrack to the correct
  1886                  line, where the display property begins.  */
  1887               if (replacing_spec_p)
  1888                 {
  1889                   Lisp_Object startpos, endpos;
  1890                   EMACS_INT start, end;
  1891                   struct it it3;
  1892 
  1893                   /* Find the first and the last buffer positions
  1894                      covered by the display string.  */
  1895                   endpos =
  1896                     Fnext_single_char_property_change (cpos, Qdisplay,
  1897                                                        Qnil, Qnil);
  1898                   startpos =
  1899                     Fprevious_single_char_property_change (endpos, Qdisplay,
  1900                                                            Qnil, Qnil);
  1901                   start = XFIXNAT (startpos);
  1902                   end = XFIXNAT (endpos);
  1903                   /* Move to the last buffer position before the
  1904                      display property.  */
  1905                   start_display (&it3, w, top);
  1906                   if (start > CHARPOS (top))
  1907                     move_it_to (&it3, start - 1, -1, -1, -1, MOVE_TO_POS);
  1908                   /* Move forward one more line if the position before
  1909                      the display string is a newline or if it is the
  1910                      rightmost character on a line that is
  1911                      continued or word-wrapped.  */
  1912                   if (it3.method == GET_FROM_BUFFER
  1913                       && (it3.c == '\n'
  1914                           || FETCH_BYTE (IT_BYTEPOS (it3)) == '\n'))
  1915                     move_it_by_lines (&it3, 1);
  1916                   else if (move_it_in_display_line_to (&it3, -1,
  1917                                                        it3.current_x
  1918                                                        + it3.pixel_width,
  1919                                                        MOVE_TO_X)
  1920                            == MOVE_LINE_CONTINUED)
  1921                     {
  1922                       move_it_by_lines (&it3, 1);
  1923                       /* When we are under word-wrap, the #$@%!
  1924                          move_it_by_lines moves 2 lines, so we need to
  1925                          fix that up.  */
  1926                       if (it3.line_wrap == WORD_WRAP)
  1927                         move_it_by_lines (&it3, -1);
  1928                     }
  1929 
  1930                   /* Record the vertical coordinate of the display
  1931                      line where we wound up.  */
  1932                   top_y = it3.current_y;
  1933                   if (it3.bidi_p)
  1934                     {
  1935                       /* When characters are reordered for display,
  1936                          the character displayed to the left of the
  1937                          display string could be _after_ the display
  1938                          property in the logical order.  Use the
  1939                          smallest vertical position of these two.  */
  1940                       start_display (&it3, w, top);
  1941                       move_it_to (&it3, end + 1, -1, -1, -1, MOVE_TO_POS);
  1942                       if (it3.current_y < top_y)
  1943                         top_y = it3.current_y;
  1944                     }
  1945                   /* Move from the top of the window to the beginning
  1946                      of the display line where the display string
  1947                      begins.  */
  1948                   start_display (&it3, w, top);
  1949                   it3.glyph_row = NULL;
  1950                   move_it_to (&it3, -1, 0, top_y, -1, MOVE_TO_X | MOVE_TO_Y);
  1951                   /* If it3_moved stays false after the 'while' loop
  1952                      below, that means we already were at a newline
  1953                      before the loop (e.g., the display string begins
  1954                      with a newline), so we don't need to return to
  1955                      the last position before the display string,
  1956                      because PRODUCE_GLYPHS will not produce anything
  1957                      for a newline.  */
  1958                   bool it3_moved = false;
  1959                   int top_x_before_string = it3.current_x;
  1960                   /* Finally, advance the iterator until we hit the
  1961                      first display element whose character position is
  1962                      at or beyond CHARPOS, or until the first newline
  1963                      from the display string, which signals the end of
  1964                      the display line.  */
  1965                   while (get_next_display_element (&it3))
  1966                     {
  1967                       if (!EQ (it3.object, string))
  1968                         top_x_before_string = it3.current_x;
  1969                       PRODUCE_GLYPHS (&it3);
  1970                       if ((it3.bidi_it.scan_dir == 1
  1971                            && IT_CHARPOS (it3) >= charpos)
  1972                           || (it3.bidi_it.scan_dir == -1
  1973                               && IT_CHARPOS (it3) <= charpos)
  1974                           || ITERATOR_AT_END_OF_LINE_P (&it3))
  1975                         break;
  1976                       it3_moved = true;
  1977                       set_iterator_to_next (&it3, false);
  1978                     }
  1979                   top_x = it3.current_x - it3.pixel_width;
  1980                   /* Account for line-number display, if IT3 still
  1981                      didn't.  This can happen if START - 1 is the
  1982                      first or the last character on its display line.  */
  1983                   if (!it3.line_number_produced_p)
  1984                     {
  1985                       if (it3.lnum_pixel_width > 0)
  1986                         {
  1987                           top_x += it3.lnum_pixel_width;
  1988                           top_x_before_string += it3.lnum_pixel_width;
  1989                         }
  1990                       else if (it.line_number_produced_p)
  1991                         {
  1992                           top_x += it.lnum_pixel_width;
  1993                           top_x_before_string += it3.lnum_pixel_width;
  1994                         }
  1995                     }
  1996                   /* Normally, we would exit the above loop because we
  1997                      found the display element whose character
  1998                      position is CHARPOS.  For the contingency that we
  1999                      didn't, and stopped at the first newline from the
  2000                      display string, reset top_x to the coordinate of
  2001                      the rightmost glyph not from the string.  */
  2002                   if (it3_moved
  2003                       && newline_in_string
  2004                       && IT_CHARPOS (it3) != charpos && EQ (it3.object, string))
  2005                     top_x = top_x_before_string;
  2006                 }
  2007             }
  2008 
  2009           *x = top_x;
  2010           /* The condition below is a heuristic fix for the situation
  2011              where move_it_to stops just after finishing the display
  2012              of a fringe bitmap, which resets it.ascent to zero, and
  2013              thus causes Y to be offset by it.max_ascent.  */
  2014           if (it.ascent == 0 && it.what == IT_IMAGE
  2015               && it.method != GET_FROM_IMAGE
  2016               && it.image_id < 0
  2017               && it.max_ascent > 0)
  2018             *y = max (top_y, window_top_y);
  2019           else
  2020             *y = max (top_y + max (0, it.max_ascent - it.ascent), window_top_y);
  2021           *rtop = max (0, window_top_y - top_y);
  2022           *rbot = max (0, bottom_y - it.last_visible_y);
  2023           *rowh = max (0, (min (bottom_y, it.last_visible_y)
  2024                            - max (top_y, window_top_y)));
  2025           *vpos = it.vpos;
  2026           if (it.bidi_it.paragraph_dir == R2L)
  2027             r2l = true;
  2028         }
  2029     }
  2030   else
  2031     {
  2032       /* Either we were asked to provide info about WINDOW_END, or
  2033          CHARPOS is in the partially visible glyph row at end of
  2034          window.  */
  2035       struct it it2;
  2036       void *it2data = NULL;
  2037 
  2038       SAVE_IT (it2, it, it2data);
  2039       if (IT_CHARPOS (it) < ZV && FETCH_BYTE (IT_BYTEPOS (it)) != '\n')
  2040         move_it_by_lines (&it, 1);
  2041       if (charpos < IT_CHARPOS (it)
  2042           || (it.what == IT_EOB && charpos == IT_CHARPOS (it)))
  2043         {
  2044           visible_p = true;
  2045           RESTORE_IT (&it2, &it2, it2data);
  2046           move_it_to (&it2, charpos, -1, -1, -1, MOVE_TO_POS);
  2047           *x = it2.current_x;
  2048           if (it2.ascent == 0 && it2.what == IT_IMAGE
  2049               && it2.method != GET_FROM_IMAGE
  2050               && it2.image_id < 0
  2051               && it2.max_ascent > 0)
  2052             *y = it2.current_y;
  2053           else
  2054             *y = it2.current_y + it2.max_ascent - it2.ascent;
  2055           *rtop = max (0, -it2.current_y);
  2056           *rbot = max (0, ((it2.current_y + it2.max_ascent + it2.max_descent)
  2057                            - it.last_visible_y));
  2058           *rowh = max (0, (min (it2.current_y + it2.max_ascent + it2.max_descent,
  2059                                 it.last_visible_y)
  2060                            - max (max (it2.current_y,
  2061                                        WINDOW_TAB_LINE_HEIGHT (w)),
  2062                                   WINDOW_HEADER_LINE_HEIGHT (w))));
  2063           *vpos = it2.vpos;
  2064           if (it2.bidi_it.paragraph_dir == R2L)
  2065             r2l = true;
  2066         }
  2067       else
  2068         bidi_unshelve_cache (it2data, true);
  2069     }
  2070   bidi_unshelve_cache (itdata, false);
  2071 
  2072   if (old_buffer)
  2073     set_buffer_internal_1 (old_buffer);
  2074 
  2075   if (visible_p)
  2076     {
  2077       if (w->hscroll > 0)
  2078         *x -=
  2079           window_hscroll_limited (w, WINDOW_XFRAME (w))
  2080           * WINDOW_FRAME_COLUMN_WIDTH (w);
  2081       /* For lines in an R2L paragraph, we need to mirror the X pixel
  2082          coordinate wrt the text area.  For the reasons, see the
  2083          commentary in buffer_posn_from_coords and the explanation of
  2084          the geometry used by the move_it_* functions at the end of
  2085          the large commentary near the beginning of this file.  */
  2086       if (r2l)
  2087         *x = window_box_width (w, TEXT_AREA) - *x - 1;
  2088     }
  2089 
  2090 #if false
  2091   /* Debugging code.  */
  2092   if (visible_p)
  2093     fprintf (stderr, "+pv pt=%d vs=%d --> x=%d y=%d rt=%d rb=%d rh=%d vp=%d\n",
  2094              charpos, w->vscroll, *x, *y, *rtop, *rbot, *rowh, *vpos);
  2095   else
  2096     fprintf (stderr, "-pv pt=%d vs=%d\n", charpos, w->vscroll);
  2097 #endif
  2098 
  2099   /* Restore potentially overwritten values.  */
  2100   w->mode_line_height = prev_mode_line_height;
  2101   w->header_line_height = prev_header_line_height;
  2102   w->tab_line_height = prev_tab_line_height;
  2103 
  2104   return visible_p;
  2105 }
  2106 
  2107 
  2108 /* Return the next character from STR.  Return in *LEN the length of
  2109    the character.  This is like string_char_and_length but never
  2110    returns an invalid character.  If we find one, we return a `?', but
  2111    with the length of the invalid character.  */
  2112 
  2113 static int
  2114 check_char_and_length (const unsigned char *str, int *len)
  2115 {
  2116   int c = string_char_and_length (str, len);
  2117   if (!CHAR_VALID_P (c))
  2118     /* We may not change the length here because other places in Emacs
  2119        don't use this function, i.e. they silently accept invalid
  2120        characters.  */
  2121     c = '?';
  2122 
  2123   return c;
  2124 }
  2125 
  2126 
  2127 
  2128 /* Given a position POS containing a valid character and byte position
  2129    in STRING, return the position NCHARS ahead (NCHARS >= 0).  */
  2130 
  2131 static struct text_pos
  2132 string_pos_nchars_ahead (struct text_pos pos, Lisp_Object string, ptrdiff_t nchars)
  2133 {
  2134   eassert (STRINGP (string) && nchars >= 0);
  2135 
  2136   if (STRING_MULTIBYTE (string))
  2137     {
  2138       const unsigned char *p = SDATA (string) + BYTEPOS (pos);
  2139 
  2140       while (nchars--)
  2141         {
  2142           int len = BYTES_BY_CHAR_HEAD (*p);
  2143           p += len;
  2144           CHARPOS (pos) += 1;
  2145           BYTEPOS (pos) += len;
  2146         }
  2147     }
  2148   else
  2149     SET_TEXT_POS (pos, CHARPOS (pos) + nchars, BYTEPOS (pos) + nchars);
  2150 
  2151   return pos;
  2152 }
  2153 
  2154 
  2155 /* Value is the text position, i.e. character and byte position,
  2156    for character position CHARPOS in STRING.  */
  2157 
  2158 static struct text_pos
  2159 string_pos (ptrdiff_t charpos, Lisp_Object string)
  2160 {
  2161   struct text_pos pos;
  2162   eassert (STRINGP (string));
  2163   eassert (charpos >= 0);
  2164   SET_TEXT_POS (pos, charpos, string_char_to_byte (string, charpos));
  2165   return pos;
  2166 }
  2167 
  2168 
  2169 /* Value is a text position, i.e. character and byte position, for
  2170    character position CHARPOS in C string S.  MULTIBYTE_P
  2171    means recognize multibyte characters.  */
  2172 
  2173 static struct text_pos
  2174 c_string_pos (ptrdiff_t charpos, const char *s, bool multibyte_p)
  2175 {
  2176   struct text_pos pos;
  2177 
  2178   eassert (s != NULL);
  2179   eassert (charpos >= 0);
  2180 
  2181   if (multibyte_p)
  2182     {
  2183       SET_TEXT_POS (pos, 0, 0);
  2184       while (charpos--)
  2185         {
  2186           int len = BYTES_BY_CHAR_HEAD (*s);
  2187           s += len;
  2188           CHARPOS (pos) += 1;
  2189           BYTEPOS (pos) += len;
  2190         }
  2191     }
  2192   else
  2193     SET_TEXT_POS (pos, charpos, charpos);
  2194 
  2195   return pos;
  2196 }
  2197 
  2198 
  2199 /* Value is the number of characters in C string S.  MULTIBYTE_P
  2200    means recognize multibyte characters.  */
  2201 
  2202 static ptrdiff_t
  2203 number_of_chars (const char *s, bool multibyte_p)
  2204 {
  2205   ptrdiff_t nchars;
  2206 
  2207   if (multibyte_p)
  2208     {
  2209       ptrdiff_t rest = strlen (s);
  2210       const unsigned char *p = (const unsigned char *) s;
  2211 
  2212       for (nchars = 0; rest > 0; ++nchars)
  2213         {
  2214           int len = BYTES_BY_CHAR_HEAD (*p);
  2215           rest -= len, p += len;
  2216         }
  2217     }
  2218   else
  2219     nchars = strlen (s);
  2220 
  2221   return nchars;
  2222 }
  2223 
  2224 
  2225 /* Compute byte position NEWPOS->bytepos corresponding to
  2226    NEWPOS->charpos.  POS is a known position in string STRING.
  2227    NEWPOS->charpos must be >= POS.charpos.  */
  2228 
  2229 static void
  2230 compute_string_pos (struct text_pos *newpos, struct text_pos pos, Lisp_Object string)
  2231 {
  2232   eassert (STRINGP (string));
  2233   eassert (CHARPOS (*newpos) >= CHARPOS (pos));
  2234 
  2235   if (STRING_MULTIBYTE (string))
  2236     *newpos = string_pos_nchars_ahead (pos, string,
  2237                                        CHARPOS (*newpos) - CHARPOS (pos));
  2238   else
  2239     BYTEPOS (*newpos) = CHARPOS (*newpos);
  2240 }
  2241 
  2242 /* EXPORT:
  2243    Return an estimation of the pixel height of mode or header lines on
  2244    frame F.  FACE_ID specifies what line's height to estimate.  */
  2245 
  2246 int
  2247 estimate_mode_line_height (struct frame *f, enum face_id face_id)
  2248 {
  2249 #ifdef HAVE_WINDOW_SYSTEM
  2250   if (FRAME_WINDOW_P (f))
  2251     {
  2252       int height = FONT_HEIGHT (FRAME_FONT (f));
  2253 
  2254       /* This function is called so early when Emacs starts that the face
  2255          cache and mode line face are not yet initialized.  */
  2256       if (FRAME_FACE_CACHE (f))
  2257         {
  2258           struct face *face = FACE_FROM_ID_OR_NULL (f, face_id);
  2259           if (face)
  2260             {
  2261               if (face->font)
  2262                 height = normal_char_height (face->font, -1);
  2263               if (face->box_horizontal_line_width > 0)
  2264                 height += 2 * face->box_horizontal_line_width;
  2265             }
  2266         }
  2267 
  2268       return height;
  2269     }
  2270 #endif
  2271 
  2272   return 1;
  2273 }
  2274 
  2275 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
  2276    coordinates in (*X, *Y).  Set *BOUNDS to the rectangle that the
  2277    glyph at X, Y occupies, if BOUNDS != 0.  If NOCLIP, do
  2278    not force the value into range.  */
  2279 
  2280 void
  2281 pixel_to_glyph_coords (struct frame *f, int pix_x, int pix_y, int *x, int *y,
  2282                        NativeRectangle *bounds, bool noclip)
  2283 {
  2284 
  2285 #ifdef HAVE_WINDOW_SYSTEM
  2286   if (FRAME_WINDOW_P (f))
  2287     {
  2288       /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to round down
  2289          even for negative values.  */
  2290       if (pix_x < 0)
  2291         pix_x -= FRAME_COLUMN_WIDTH (f) - 1;
  2292       if (pix_y < 0)
  2293         pix_y -= FRAME_LINE_HEIGHT (f) - 1;
  2294 
  2295       pix_x = FRAME_PIXEL_X_TO_COL (f, pix_x);
  2296       pix_y = FRAME_PIXEL_Y_TO_LINE (f, pix_y);
  2297 
  2298       if (bounds)
  2299         STORE_NATIVE_RECT (*bounds,
  2300                            FRAME_COL_TO_PIXEL_X (f, pix_x),
  2301                            FRAME_LINE_TO_PIXEL_Y (f, pix_y),
  2302                            FRAME_COLUMN_WIDTH (f) - 1,
  2303                            FRAME_LINE_HEIGHT (f) - 1);
  2304 
  2305       /* PXW: Should we clip pixels before converting to columns/lines?  */
  2306       if (!noclip)
  2307         {
  2308           if (pix_x < 0)
  2309             pix_x = 0;
  2310           else if (pix_x > FRAME_TOTAL_COLS (f))
  2311             pix_x = FRAME_TOTAL_COLS (f);
  2312 
  2313           if (pix_y < 0)
  2314             pix_y = 0;
  2315           else if (pix_y > FRAME_TOTAL_LINES (f))
  2316             pix_y = FRAME_TOTAL_LINES (f);
  2317         }
  2318     }
  2319 #endif
  2320 
  2321   *x = pix_x;
  2322   *y = pix_y;
  2323 }
  2324 
  2325 
  2326 /* Find the glyph under window-relative coordinates X/Y in window W.
  2327    Consider only glyphs from buffer text, i.e. no glyphs from overlay
  2328    strings.  Return in *HPOS and *VPOS the row and column number of
  2329    the glyph found.  Return in *AREA the glyph area containing X.
  2330    Value is a pointer to the glyph found or null if X/Y is not on
  2331    text, or we can't tell because W's current matrix is not up to
  2332    date.  */
  2333 
  2334 struct glyph *
  2335 x_y_to_hpos_vpos (struct window *w, int x, int y, int *hpos, int *vpos,
  2336                   int *dx, int *dy, int *area)
  2337 {
  2338   struct glyph *glyph, *end;
  2339   struct glyph_row *row = NULL;
  2340   int x0, i;
  2341 
  2342   /* Find row containing Y.  Give up if some row is not enabled.  */
  2343   for (i = 0; i < w->current_matrix->nrows; ++i)
  2344     {
  2345       row = MATRIX_ROW (w->current_matrix, i);
  2346       if (!row->enabled_p)
  2347         return NULL;
  2348       if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
  2349         break;
  2350     }
  2351 
  2352   *vpos = i;
  2353   *hpos = 0;
  2354 
  2355   /* Give up if Y is not in the window.  */
  2356   if (i == w->current_matrix->nrows)
  2357     return NULL;
  2358 
  2359   /* Get the glyph area containing X.  */
  2360   if (w->pseudo_window_p)
  2361     {
  2362       *area = TEXT_AREA;
  2363       x0 = 0;
  2364     }
  2365   else
  2366     {
  2367       if (x < window_box_left_offset (w, TEXT_AREA))
  2368         {
  2369           *area = LEFT_MARGIN_AREA;
  2370           x0 = window_box_left_offset (w, LEFT_MARGIN_AREA);
  2371         }
  2372       else if (x < window_box_right_offset (w, TEXT_AREA))
  2373         {
  2374           *area = TEXT_AREA;
  2375           x0 = window_box_left_offset (w, TEXT_AREA) + min (row->x, 0);
  2376         }
  2377       else
  2378         {
  2379           *area = RIGHT_MARGIN_AREA;
  2380           x0 = window_box_left_offset (w, RIGHT_MARGIN_AREA);
  2381         }
  2382     }
  2383 
  2384   /* Find glyph containing X.  */
  2385   glyph = row->glyphs[*area];
  2386   end = glyph + row->used[*area];
  2387   x -= x0;
  2388   while (glyph < end && x >= glyph->pixel_width)
  2389     {
  2390       x -= glyph->pixel_width;
  2391       ++glyph;
  2392     }
  2393 
  2394   if (glyph == end)
  2395     return NULL;
  2396 
  2397   if (dx)
  2398     {
  2399       *dx = x;
  2400       *dy = y - (row->y + row->ascent - glyph->ascent);
  2401     }
  2402 
  2403   *hpos = glyph - row->glyphs[*area];
  2404   return glyph;
  2405 }
  2406 
  2407 /* Convert frame-relative x/y to coordinates relative to window W.
  2408    Takes pseudo-windows into account.  */
  2409 
  2410 static void
  2411 frame_to_window_pixel_xy (struct window *w, int *x, int *y)
  2412 {
  2413   if (w->pseudo_window_p)
  2414     {
  2415       /* A pseudo-window is always full-width, and starts at the
  2416          left edge of the frame, plus a frame border.  */
  2417       struct frame *f = XFRAME (w->frame);
  2418       *x -= FRAME_INTERNAL_BORDER_WIDTH (f);
  2419       *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
  2420     }
  2421   else
  2422     {
  2423       *x -= WINDOW_LEFT_EDGE_X (w);
  2424       *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
  2425     }
  2426 }
  2427 
  2428 #ifdef HAVE_WINDOW_SYSTEM
  2429 
  2430 /* EXPORT:
  2431    Return in RECTS[] at most N clipping rectangles for glyph string S.
  2432    Return the number of stored rectangles.  */
  2433 
  2434 int
  2435 get_glyph_string_clip_rects (struct glyph_string *s, NativeRectangle *rects, int n)
  2436 {
  2437   Emacs_Rectangle r;
  2438 
  2439   if (n <= 0)
  2440     return 0;
  2441 
  2442   if (s->row->full_width_p)
  2443     {
  2444       /* Draw full-width.  X coordinates are relative to S->w->left_col.  */
  2445       r.x = WINDOW_LEFT_EDGE_X (s->w);
  2446       if (s->row->mode_line_p)
  2447         r.width = WINDOW_PIXEL_WIDTH (s->w) - WINDOW_RIGHT_DIVIDER_WIDTH (s->w);
  2448       else
  2449         r.width = WINDOW_PIXEL_WIDTH (s->w);
  2450 
  2451       /* Unless displaying a mode or menu bar line, which are always
  2452          fully visible, clip to the visible part of the row.  */
  2453       if (s->w->pseudo_window_p)
  2454         r.height = s->row->visible_height;
  2455       else
  2456         r.height = s->height;
  2457     }
  2458   else
  2459     {
  2460       /* This is a text line that may be partially visible.  */
  2461       r.x = window_box_left (s->w, s->area);
  2462       r.width = window_box_width (s->w, s->area);
  2463       r.height = s->row->visible_height;
  2464     }
  2465 
  2466   if (s->clip_head)
  2467     if (r.x < s->clip_head->x)
  2468       {
  2469         if (r.width >= s->clip_head->x - r.x)
  2470           r.width -= s->clip_head->x - r.x;
  2471         else
  2472           r.width = 0;
  2473         r.x = s->clip_head->x;
  2474       }
  2475   if (s->clip_tail)
  2476     if (r.x + r.width > s->clip_tail->x + s->clip_tail->background_width)
  2477       {
  2478         if (s->clip_tail->x + s->clip_tail->background_width >= r.x)
  2479           r.width = s->clip_tail->x + s->clip_tail->background_width - r.x;
  2480         else
  2481           r.width = 0;
  2482       }
  2483 
  2484   /* If S draws overlapping rows, it's sufficient to use the top and
  2485      bottom of the window for clipping because this glyph string
  2486      intentionally draws over other lines.  */
  2487   if (s->for_overlaps)
  2488     {
  2489       r.y = WINDOW_TAB_LINE_HEIGHT (s->w) + WINDOW_HEADER_LINE_HEIGHT (s->w);
  2490       r.height = window_text_bottom_y (s->w) - r.y;
  2491 
  2492       /* Alas, the above simple strategy does not work for the
  2493          environments with anti-aliased text: if the same text is
  2494          drawn onto the same place multiple times, it gets thicker.
  2495          If the overlap we are processing is for the erased cursor, we
  2496          take the intersection with the rectangle of the cursor.  */
  2497       if (s->for_overlaps & OVERLAPS_ERASED_CURSOR)
  2498         {
  2499           Emacs_Rectangle rc, r_save = r;
  2500 
  2501           rc.x = WINDOW_TEXT_TO_FRAME_PIXEL_X (s->w, s->w->phys_cursor.x);
  2502           rc.y = s->w->phys_cursor.y;
  2503           rc.width = s->w->phys_cursor_width;
  2504           rc.height = s->w->phys_cursor_height;
  2505 
  2506           gui_intersect_rectangles (&r_save, &rc, &r);
  2507         }
  2508     }
  2509   else
  2510     {
  2511       /* Don't use S->y for clipping because it doesn't take partially
  2512          visible lines into account.  For example, it can be negative for
  2513          partially visible lines at the top of a window.  */
  2514       if (!s->row->full_width_p
  2515           && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
  2516         r.y = WINDOW_TAB_LINE_HEIGHT (s->w) + WINDOW_HEADER_LINE_HEIGHT (s->w);
  2517       else
  2518         r.y = max (0, s->row->y);
  2519     }
  2520 
  2521   r.y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r.y);
  2522 
  2523   /* If drawing the cursor, don't let glyph draw outside its
  2524      advertised boundaries. Cleartype does this under some circumstances.  */
  2525   if (s->hl == DRAW_CURSOR)
  2526     {
  2527       struct glyph *glyph = s->first_glyph;
  2528       int height, max_y;
  2529 
  2530       if (s->x > r.x)
  2531         {
  2532           if (r.width >= s->x - r.x)
  2533             r.width -= s->x - r.x;
  2534           else  /* R2L hscrolled row with cursor outside text area */
  2535             r.width = 0;
  2536           r.x = s->x;
  2537         }
  2538       r.width = min (r.width, glyph->pixel_width);
  2539 
  2540       /* If r.y is below window bottom, ensure that we still see a cursor.  */
  2541       height = min (glyph->ascent + glyph->descent,
  2542                     min (FRAME_LINE_HEIGHT (s->f), s->row->visible_height));
  2543       max_y = window_text_bottom_y (s->w) - height;
  2544       max_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, max_y);
  2545       if (s->ybase - glyph->ascent > max_y)
  2546         {
  2547           r.y = max_y;
  2548           r.height = height;
  2549         }
  2550       else
  2551         {
  2552           /* Don't draw cursor glyph taller than our actual glyph.  */
  2553           height = max (FRAME_LINE_HEIGHT (s->f), glyph->ascent + glyph->descent);
  2554           if (height < r.height)
  2555             {
  2556               max_y = r.y + r.height;
  2557               r.y = min (max_y, max (r.y, s->ybase + glyph->descent - height));
  2558               r.height = min (max_y - r.y, height);
  2559             }
  2560         }
  2561     }
  2562 
  2563   if (s->row->clip)
  2564     {
  2565       Emacs_Rectangle r_save = r;
  2566 
  2567       if (! gui_intersect_rectangles (&r_save, s->row->clip, &r))
  2568         r.width = 0;
  2569     }
  2570 
  2571   if ((s->for_overlaps & OVERLAPS_BOTH) == 0
  2572       || ((s->for_overlaps & OVERLAPS_BOTH) == OVERLAPS_BOTH && n == 1))
  2573     {
  2574 #ifdef CONVERT_FROM_EMACS_RECT
  2575       CONVERT_FROM_EMACS_RECT (r, *rects);
  2576 #else
  2577       *rects = r;
  2578 #endif
  2579       return 1;
  2580     }
  2581   else
  2582     {
  2583       /* If we are processing overlapping and allowed to return
  2584          multiple clipping rectangles, we exclude the row of the glyph
  2585          string from the clipping rectangle.  This is to avoid drawing
  2586          the same text on the environment with anti-aliasing.  */
  2587 #ifdef CONVERT_FROM_EMACS_RECT
  2588       Emacs_Rectangle rs[2];
  2589 #else
  2590       Emacs_Rectangle *rs = rects;
  2591 #endif
  2592       int i = 0, row_y = WINDOW_TO_FRAME_PIXEL_Y (s->w, s->row->y);
  2593 
  2594       if (s->for_overlaps & OVERLAPS_PRED)
  2595         {
  2596           rs[i] = r;
  2597           if (r.y + r.height > row_y)
  2598             {
  2599               if (r.y < row_y)
  2600                 rs[i].height = row_y - r.y;
  2601               else
  2602                 rs[i].height = 0;
  2603             }
  2604           i++;
  2605         }
  2606       if (s->for_overlaps & OVERLAPS_SUCC)
  2607         {
  2608           rs[i] = r;
  2609           if (r.y < row_y + s->row->visible_height)
  2610             {
  2611               if (r.y + r.height > row_y + s->row->visible_height)
  2612                 {
  2613                   rs[i].y = row_y + s->row->visible_height;
  2614                   rs[i].height = r.y + r.height - rs[i].y;
  2615                 }
  2616               else
  2617                 rs[i].height = 0;
  2618             }
  2619           i++;
  2620         }
  2621 
  2622       n = i;
  2623 #ifdef CONVERT_FROM_EMACS_RECT
  2624       for (i = 0; i < n; i++)
  2625         CONVERT_FROM_EMACS_RECT (rs[i], rects[i]);
  2626 #endif
  2627       return n;
  2628     }
  2629 }
  2630 
  2631 /* EXPORT:
  2632    Return in *NR the clipping rectangle for glyph string S.  */
  2633 
  2634 void
  2635 get_glyph_string_clip_rect (struct glyph_string *s, NativeRectangle *nr)
  2636 {
  2637   get_glyph_string_clip_rects (s, nr, 1);
  2638 }
  2639 
  2640 
  2641 /* EXPORT:
  2642    Return the position and height of the phys cursor in window W.
  2643    Set w->phys_cursor_width to width of phys cursor.
  2644 */
  2645 
  2646 void
  2647 get_phys_cursor_geometry (struct window *w, struct glyph_row *row,
  2648                           struct glyph *glyph, int *xp, int *yp, int *heightp)
  2649 {
  2650   struct frame *f = XFRAME (WINDOW_FRAME (w));
  2651   int x, y, wd, h, h0, y0, ascent;
  2652 
  2653   /* Compute the width of the rectangle to draw.  If on a stretch
  2654      glyph, and `x-stretch-cursor' is nil, don't draw a rectangle
  2655      as wide as the glyph, but use a canonical character width
  2656      instead.  */
  2657   wd = glyph->pixel_width;
  2658 
  2659   x = w->phys_cursor.x;
  2660   if (x < 0)
  2661     {
  2662       wd += x;
  2663       x = 0;
  2664     }
  2665 
  2666   if (glyph->type == STRETCH_GLYPH
  2667       && !x_stretch_cursor_p)
  2668     wd = min (FRAME_COLUMN_WIDTH (f), wd);
  2669   w->phys_cursor_width = wd;
  2670 
  2671   /* Don't let the hollow cursor glyph descend below the glyph row's
  2672      ascent value, lest the hollow cursor looks funny.  */
  2673   y = w->phys_cursor.y;
  2674   ascent = row->ascent;
  2675   /* The test for row at ZV is for when line numbers are displayed and
  2676      point is at EOB: the cursor could then be smaller or larger than
  2677      the default face's font.  */
  2678   if (!row->ends_at_zv_p && row->ascent < glyph->ascent)
  2679     {
  2680       y -= glyph->ascent - row->ascent;
  2681       ascent = glyph->ascent;
  2682     }
  2683 
  2684   /* If y is below window bottom, ensure that we still see a cursor.  */
  2685   h0 = min (FRAME_LINE_HEIGHT (f), row->visible_height);
  2686 
  2687   h = max (h0, ascent + glyph->descent);
  2688   /* Don't let the cursor exceed the dimensions of the row, so that
  2689      the upper/lower side of the box aren't clipped.  */
  2690   h = min (h, row->height);
  2691   h0 = min (h0, ascent + glyph->descent);
  2692 
  2693   y0 = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
  2694   if (y < y0)
  2695     {
  2696       h = max (h - (y0 - y) + 1, h0);
  2697       y = y0 - 1;
  2698     }
  2699   else
  2700     {
  2701       y0 = window_text_bottom_y (w) - h0;
  2702       if (y > y0)
  2703         {
  2704           h += y - y0;
  2705           y = y0;
  2706         }
  2707     }
  2708 
  2709   *xp = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x);
  2710   *yp = WINDOW_TO_FRAME_PIXEL_Y (w, y);
  2711   *heightp = h;
  2712 }
  2713 
  2714 /*
  2715  * Remember which glyph the mouse is over.
  2716  */
  2717 
  2718 void
  2719 remember_mouse_glyph (struct frame *f, int gx, int gy, NativeRectangle *rect)
  2720 {
  2721   Lisp_Object window;
  2722   struct window *w;
  2723   struct glyph_row *r, *gr, *end_row;
  2724   enum window_part part;
  2725   enum glyph_row_area area;
  2726   int x, y, width, height;
  2727 
  2728   if (mouse_fine_grained_tracking)
  2729     {
  2730       STORE_NATIVE_RECT (*rect, gx, gy, 1, 1);
  2731       return;
  2732     }
  2733 
  2734   /* Try to determine frame pixel position and size of the glyph under
  2735      frame pixel coordinates X/Y on frame F.  */
  2736 
  2737   if (window_resize_pixelwise)
  2738     {
  2739       width = height = 1;
  2740       goto virtual_glyph;
  2741     }
  2742   else if (!f->glyphs_initialized_p
  2743            || (window = window_from_coordinates (f, gx, gy, &part, false, false),
  2744                NILP (window)))
  2745     {
  2746       width = FRAME_SMALLEST_CHAR_WIDTH (f);
  2747       height = FRAME_SMALLEST_FONT_HEIGHT (f);
  2748       goto virtual_glyph;
  2749     }
  2750 
  2751   w = XWINDOW (window);
  2752   width = WINDOW_FRAME_COLUMN_WIDTH (w);
  2753   height = WINDOW_FRAME_LINE_HEIGHT (w);
  2754 
  2755   x = window_relative_x_coord (w, part, gx);
  2756   y = gy - WINDOW_TOP_EDGE_Y (w);
  2757 
  2758   r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
  2759   end_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
  2760 
  2761   if (w->pseudo_window_p)
  2762     {
  2763       area = TEXT_AREA;
  2764       part = ON_MODE_LINE; /* Don't adjust margin. */
  2765       goto text_glyph;
  2766     }
  2767 
  2768   switch (part)
  2769     {
  2770     case ON_LEFT_MARGIN:
  2771       area = LEFT_MARGIN_AREA;
  2772       goto text_glyph;
  2773 
  2774     case ON_RIGHT_MARGIN:
  2775       area = RIGHT_MARGIN_AREA;
  2776       goto text_glyph;
  2777 
  2778     case ON_TAB_LINE:
  2779     case ON_HEADER_LINE:
  2780     case ON_MODE_LINE:
  2781       gr = (part == ON_TAB_LINE
  2782             ? MATRIX_TAB_LINE_ROW (w->current_matrix)
  2783             : (part == ON_HEADER_LINE
  2784                ? MATRIX_HEADER_LINE_ROW (w->current_matrix)
  2785                : MATRIX_MODE_LINE_ROW (w->current_matrix)));
  2786       gy = gr->y;
  2787       area = TEXT_AREA;
  2788       goto text_glyph_row_found;
  2789 
  2790     case ON_TEXT:
  2791       area = TEXT_AREA;
  2792 
  2793     text_glyph:
  2794       gr = 0; gy = 0;
  2795       for (; r <= end_row && r->enabled_p; ++r)
  2796         if (r->y + r->height > y)
  2797           {
  2798             gr = r; gy = r->y;
  2799             break;
  2800           }
  2801 
  2802     text_glyph_row_found:
  2803       if (gr && gy <= y)
  2804         {
  2805           struct glyph *g = gr->glyphs[area];
  2806           struct glyph *end = g + gr->used[area];
  2807 
  2808           height = gr->height;
  2809           for (gx = gr->x; g < end; gx += g->pixel_width, ++g)
  2810             if (gx + g->pixel_width > x)
  2811               break;
  2812 
  2813           if (g < end)
  2814             {
  2815               if (g->type == IMAGE_GLYPH)
  2816                 {
  2817                   /* Don't remember when mouse is over image, as
  2818                      image may have hot-spots.  */
  2819                   STORE_NATIVE_RECT (*rect, 0, 0, 0, 0);
  2820                   return;
  2821                 }
  2822               width = g->pixel_width;
  2823             }
  2824           else
  2825             {
  2826               /* Use nominal char spacing at end of line.  */
  2827               x -= gx;
  2828               gx += (x / width) * width;
  2829             }
  2830 
  2831           if (part != ON_MODE_LINE && part != ON_HEADER_LINE
  2832               && part != ON_TAB_LINE)
  2833             {
  2834               gx += window_box_left_offset (w, area);
  2835               /* Don't expand over the modeline to make sure the vertical
  2836                  drag cursor is shown early enough.  */
  2837               height = min (height,
  2838                             max (0, WINDOW_BOX_HEIGHT_NO_MODE_LINE (w) - gy));
  2839             }
  2840         }
  2841       else
  2842         {
  2843           /* Use nominal line height at end of window.  */
  2844           gx = (x / width) * width;
  2845           y -= gy;
  2846           gy += (y / height) * height;
  2847           if (part != ON_MODE_LINE && part != ON_HEADER_LINE
  2848               && part != ON_TAB_LINE)
  2849             /* See comment above.  */
  2850             height = min (height,
  2851                           max (0, WINDOW_BOX_HEIGHT_NO_MODE_LINE (w) - gy));
  2852         }
  2853       break;
  2854 
  2855     case ON_LEFT_FRINGE:
  2856       gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  2857             ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w)
  2858             : window_box_right_offset (w, LEFT_MARGIN_AREA));
  2859       width = WINDOW_LEFT_FRINGE_WIDTH (w);
  2860       goto row_glyph;
  2861 
  2862     case ON_RIGHT_FRINGE:
  2863       gx = (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  2864             ? window_box_right_offset (w, RIGHT_MARGIN_AREA)
  2865             : window_box_right_offset (w, TEXT_AREA));
  2866       if (WINDOW_RIGHT_DIVIDER_WIDTH (w) == 0
  2867           && !WINDOW_HAS_VERTICAL_SCROLL_BAR (w)
  2868           && !WINDOW_RIGHTMOST_P (w))
  2869         if (gx < WINDOW_PIXEL_WIDTH (w) - width)
  2870           /* Make sure the vertical border can get her own glyph to the
  2871              right of the one we build here.  */
  2872           width = WINDOW_RIGHT_FRINGE_WIDTH (w) - width;
  2873         else
  2874           width = WINDOW_PIXEL_WIDTH (w) - gx;
  2875       else
  2876         width = WINDOW_RIGHT_FRINGE_WIDTH (w);
  2877 
  2878       goto row_glyph;
  2879 
  2880     case ON_VERTICAL_BORDER:
  2881       gx = WINDOW_PIXEL_WIDTH (w) - width;
  2882       goto row_glyph;
  2883 
  2884     case ON_VERTICAL_SCROLL_BAR:
  2885       gx = (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w)
  2886             ? 0
  2887             : (window_box_right_offset (w, RIGHT_MARGIN_AREA)
  2888                + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
  2889                   ? WINDOW_RIGHT_FRINGE_WIDTH (w)
  2890                   : 0)));
  2891       width = WINDOW_SCROLL_BAR_AREA_WIDTH (w);
  2892 
  2893     row_glyph:
  2894       gr = 0, gy = 0;
  2895       for (; r <= end_row && r->enabled_p; ++r)
  2896         if (r->y + r->height > y)
  2897           {
  2898             gr = r; gy = r->y;
  2899             break;
  2900           }
  2901 
  2902       if (gr && gy <= y)
  2903         height = gr->height;
  2904       else
  2905         {
  2906           /* Use nominal line height at end of window.  */
  2907           y -= gy;
  2908           gy += (y / height) * height;
  2909         }
  2910       break;
  2911 
  2912     case ON_RIGHT_DIVIDER:
  2913       gx = WINDOW_PIXEL_WIDTH (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
  2914       width = WINDOW_RIGHT_DIVIDER_WIDTH (w);
  2915       gy = 0;
  2916       /* The bottom divider prevails. */
  2917       height = WINDOW_PIXEL_HEIGHT (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  2918       goto add_edge;
  2919 
  2920     case ON_BOTTOM_DIVIDER:
  2921       gx = 0;
  2922       width = WINDOW_PIXEL_WIDTH (w);
  2923       gy = WINDOW_PIXEL_HEIGHT (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  2924       height = WINDOW_BOTTOM_DIVIDER_WIDTH (w);
  2925       goto add_edge;
  2926 
  2927     default:
  2928       ;
  2929     virtual_glyph:
  2930       /* If there is no glyph under the mouse, then we divide the screen
  2931          into a grid of the smallest glyph in the frame, and use that
  2932          as our "glyph".  */
  2933 
  2934       /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
  2935          round down even for negative values.  */
  2936       if (gx < 0)
  2937         gx -= width - 1;
  2938       if (gy < 0)
  2939         gy -= height - 1;
  2940 
  2941       gx = (gx / width) * width;
  2942       gy = (gy / height) * height;
  2943 
  2944       goto store_rect;
  2945     }
  2946 
  2947  add_edge:
  2948   gx += WINDOW_LEFT_EDGE_X (w);
  2949   gy += WINDOW_TOP_EDGE_Y (w);
  2950 
  2951  store_rect:
  2952   STORE_NATIVE_RECT (*rect, gx, gy, width, height);
  2953 
  2954   /* Visible feedback for debugging.  */
  2955 #if false && defined HAVE_X_WINDOWS
  2956   XDrawRectangle (FRAME_X_DISPLAY (f), FRAME_X_DRAWABLE (f),
  2957                   f->output_data.x->normal_gc,
  2958                   gx, gy, width, height);
  2959 #endif
  2960 }
  2961 
  2962 
  2963 #endif /* HAVE_WINDOW_SYSTEM */
  2964 
  2965 static void
  2966 adjust_window_ends (struct window *w, struct glyph_row *row, bool current)
  2967 {
  2968   eassert (w);
  2969   w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
  2970   w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
  2971   w->window_end_vpos
  2972     = MATRIX_ROW_VPOS (row, current ? w->current_matrix : w->desired_matrix);
  2973 }
  2974 
  2975 static bool
  2976 hscrolling_current_line_p (struct window *w)
  2977 {
  2978   return (!w->suspend_auto_hscroll
  2979           && EQ (Fbuffer_local_value (Qauto_hscroll_mode, w->contents),
  2980                  Qcurrent_line));
  2981 }
  2982 
  2983 /***********************************************************************
  2984                         Lisp form evaluation
  2985  ***********************************************************************/
  2986 
  2987 /* Error handler for safe_eval and safe_call.  */
  2988 
  2989 static Lisp_Object
  2990 safe_eval_handler (Lisp_Object arg, ptrdiff_t nargs, Lisp_Object *args)
  2991 {
  2992   add_to_log ("Error during redisplay: %S signaled %S",
  2993               Flist (nargs, args), arg);
  2994   return Qnil;
  2995 }
  2996 
  2997 /* Call function FUNC with the rest of NARGS - 1 arguments
  2998    following.  Return the result, or nil if something went
  2999    wrong.  Prevent redisplay during the evaluation.  */
  3000 
  3001 static Lisp_Object
  3002 safe__call (bool inhibit_quit, ptrdiff_t nargs, Lisp_Object func, va_list ap)
  3003 {
  3004   Lisp_Object val;
  3005 
  3006   if (inhibit_eval_during_redisplay)
  3007     val = Qnil;
  3008   else
  3009     {
  3010       ptrdiff_t i;
  3011       specpdl_ref count = SPECPDL_INDEX ();
  3012       Lisp_Object *args;
  3013       USE_SAFE_ALLOCA;
  3014       SAFE_ALLOCA_LISP (args, nargs);
  3015 
  3016       args[0] = func;
  3017       for (i = 1; i < nargs; i++)
  3018         args[i] = va_arg (ap, Lisp_Object);
  3019 
  3020       specbind (Qinhibit_redisplay, Qt);
  3021       if (inhibit_quit)
  3022         specbind (Qinhibit_quit, Qt);
  3023       /* Use Qt to ensure debugger does not run,
  3024          so there is no possibility of wanting to redisplay.  */
  3025       val = internal_condition_case_n (Ffuncall, nargs, args, Qt,
  3026                                        safe_eval_handler);
  3027       val = SAFE_FREE_UNBIND_TO (count, val);
  3028     }
  3029 
  3030   return val;
  3031 }
  3032 
  3033 Lisp_Object
  3034 safe_call (ptrdiff_t nargs, Lisp_Object func, ...)
  3035 {
  3036   Lisp_Object retval;
  3037   va_list ap;
  3038 
  3039   va_start (ap, func);
  3040   retval = safe__call (false, nargs, func, ap);
  3041   va_end (ap);
  3042   return retval;
  3043 }
  3044 
  3045 /* Call function FN with one argument ARG.
  3046    Return the result, or nil if something went wrong.  */
  3047 
  3048 Lisp_Object
  3049 safe_call1 (Lisp_Object fn, Lisp_Object arg)
  3050 {
  3051   return safe_call (2, fn, arg);
  3052 }
  3053 
  3054 static Lisp_Object
  3055 safe__call1 (bool inhibit_quit, Lisp_Object fn, ...)
  3056 {
  3057   Lisp_Object retval;
  3058   va_list ap;
  3059 
  3060   va_start (ap, fn);
  3061   retval = safe__call (inhibit_quit, 2, fn, ap);
  3062   va_end (ap);
  3063   return retval;
  3064 }
  3065 
  3066 Lisp_Object
  3067 safe_eval (Lisp_Object sexpr)
  3068 {
  3069   return safe__call1 (false, Qeval, sexpr);
  3070 }
  3071 
  3072 static Lisp_Object
  3073 safe__eval (bool inhibit_quit, Lisp_Object sexpr)
  3074 {
  3075   return safe__call1 (inhibit_quit, Qeval, sexpr);
  3076 }
  3077 
  3078 /* Call function FN with two arguments ARG1 and ARG2.
  3079    Return the result, or nil if something went wrong.  */
  3080 
  3081 Lisp_Object
  3082 safe_call2 (Lisp_Object fn, Lisp_Object arg1, Lisp_Object arg2)
  3083 {
  3084   return safe_call (3, fn, arg1, arg2);
  3085 }
  3086 
  3087 
  3088 
  3089 /***********************************************************************
  3090                               Debugging
  3091  ***********************************************************************/
  3092 
  3093 /* Define CHECK_IT to perform sanity checks on iterators.
  3094    This is for debugging.  It is too slow to do unconditionally.  */
  3095 
  3096 static void
  3097 CHECK_IT (struct it *it)
  3098 {
  3099 #if false
  3100   if (it->method == GET_FROM_STRING)
  3101     {
  3102       eassert (STRINGP (it->string));
  3103       eassert (IT_STRING_CHARPOS (*it) >= 0);
  3104     }
  3105   else
  3106     {
  3107       eassert (IT_STRING_CHARPOS (*it) < 0);
  3108       if (it->method == GET_FROM_BUFFER)
  3109         {
  3110           /* Check that character and byte positions agree.  */
  3111           eassert (IT_CHARPOS (*it) == BYTE_TO_CHAR (IT_BYTEPOS (*it)));
  3112         }
  3113     }
  3114 
  3115   if (it->dpvec)
  3116     eassert (it->current.dpvec_index >= 0);
  3117   else
  3118     eassert (it->current.dpvec_index < 0);
  3119 #endif
  3120 }
  3121 
  3122 
  3123 /* Check that the window end of window W is what we expect it
  3124    to be---the last row in the current matrix displaying text.  */
  3125 
  3126 static void
  3127 CHECK_WINDOW_END (struct window *w)
  3128 {
  3129 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
  3130   if (!MINI_WINDOW_P (w) && w->window_end_valid)
  3131     {
  3132       struct glyph_row *row;
  3133       eassert ((row = MATRIX_ROW (w->current_matrix, w->window_end_vpos),
  3134                 !row->enabled_p
  3135                 || MATRIX_ROW_DISPLAYS_TEXT_P (row)
  3136                 || MATRIX_ROW_VPOS (row, w->current_matrix) == 0));
  3137     }
  3138 #endif
  3139 }
  3140 
  3141 /***********************************************************************
  3142                        Iterator initialization
  3143  ***********************************************************************/
  3144 
  3145 /* Initialize IT for displaying current_buffer in window W, starting
  3146    at character position CHARPOS.  CHARPOS < 0 means that no buffer
  3147    position is specified which is useful when the iterator is assigned
  3148    a position later.  BYTEPOS is the byte position corresponding to
  3149    CHARPOS.
  3150 
  3151    If ROW is not null, calls to produce_glyphs with IT as parameter
  3152    will produce glyphs in that row.
  3153 
  3154    BASE_FACE_ID is the id of a base face to use.  It must be one of
  3155    DEFAULT_FACE_ID for normal text, MODE_LINE_ACTIVE_FACE_ID,
  3156    MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID for displaying
  3157    mode lines, or TOOL_BAR_FACE_ID for displaying the tool-bar.
  3158 
  3159    If ROW is null and BASE_FACE_ID is equal to MODE_LINE_ACTIVE_FACE_ID,
  3160    MODE_LINE_INACTIVE_FACE_ID, or HEADER_LINE_FACE_ID, the iterator
  3161    will be initialized to use the corresponding mode line glyph row of
  3162    the desired matrix of W.  */
  3163 
  3164 void
  3165 init_iterator (struct it *it, struct window *w,
  3166                ptrdiff_t charpos, ptrdiff_t bytepos,
  3167                struct glyph_row *row, enum face_id base_face_id)
  3168 {
  3169   enum face_id remapped_base_face_id = base_face_id;
  3170   int body_width = 0, body_height = 0;
  3171 
  3172   /* Some precondition checks.  */
  3173   eassert (w != NULL && it != NULL);
  3174   eassert (charpos < 0 || (charpos >= BUF_BEG (current_buffer)
  3175                            && charpos <= ZV));
  3176 
  3177   /* If face attributes have been changed since the last redisplay,
  3178      free realized faces now because they depend on face definitions
  3179      that might have changed.  Don't free faces while there might be
  3180      desired matrices pending which reference these faces.  */
  3181   if (!inhibit_free_realized_faces)
  3182     {
  3183       if (face_change)
  3184         {
  3185           face_change = false;
  3186           XFRAME (w->frame)->face_change = 0;
  3187           free_all_realized_faces (Qnil);
  3188         }
  3189       else if (XFRAME (w->frame)->face_change)
  3190         {
  3191           XFRAME (w->frame)->face_change = 0;
  3192           free_all_realized_faces (w->frame);
  3193         }
  3194     }
  3195 
  3196   /* Perhaps remap BASE_FACE_ID to a user-specified alternative.  */
  3197   if (! NILP (Vface_remapping_alist))
  3198     remapped_base_face_id
  3199       = lookup_basic_face (w, XFRAME (w->frame), base_face_id);
  3200 
  3201   /* Use one of the mode line rows of W's desired matrix if
  3202      appropriate.  */
  3203   if (row == NULL)
  3204     {
  3205       if (base_face_id == MODE_LINE_ACTIVE_FACE_ID
  3206           || base_face_id == MODE_LINE_INACTIVE_FACE_ID)
  3207         row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
  3208       else if (base_face_id == TAB_LINE_FACE_ID)
  3209         row = MATRIX_TAB_LINE_ROW (w->desired_matrix);
  3210       else if (base_face_id == HEADER_LINE_FACE_ID)
  3211         {
  3212           /* Header line row depends on whether tab line is enabled.  */
  3213           w->desired_matrix->tab_line_p = window_wants_tab_line (w);
  3214           row = MATRIX_HEADER_LINE_ROW (w->desired_matrix);
  3215         }
  3216     }
  3217 
  3218   /* Clear IT, and set it->object and other IT's Lisp objects to Qnil.
  3219      Other parts of redisplay rely on that.  */
  3220   memclear (it, sizeof *it);
  3221   it->current.overlay_string_index = -1;
  3222   it->current.dpvec_index = -1;
  3223   it->base_face_id = remapped_base_face_id;
  3224   IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
  3225   it->paragraph_embedding = L2R;
  3226   it->bidi_it.w = w;
  3227 
  3228   /* The window in which we iterate over current_buffer:  */
  3229   XSETWINDOW (it->window, w);
  3230   it->w = w;
  3231   it->f = XFRAME (w->frame);
  3232 
  3233   it->cmp_it.id = -1;
  3234   it->cmp_it.parent_it = it;
  3235 
  3236   if (max_redisplay_ticks > 0)
  3237     update_redisplay_ticks (0, w);
  3238 
  3239   /* Extra space between lines (on window systems only).  */
  3240   if (base_face_id == DEFAULT_FACE_ID
  3241       && FRAME_WINDOW_P (it->f))
  3242     {
  3243       if (FIXNATP (BVAR (current_buffer, extra_line_spacing)))
  3244         it->extra_line_spacing = XFIXNAT (BVAR (current_buffer, extra_line_spacing));
  3245       else if (FLOATP (BVAR (current_buffer, extra_line_spacing)))
  3246         it->extra_line_spacing = (XFLOAT_DATA (BVAR (current_buffer, extra_line_spacing))
  3247                                   * FRAME_LINE_HEIGHT (it->f));
  3248       else if (it->f->extra_line_spacing > 0)
  3249         it->extra_line_spacing = it->f->extra_line_spacing;
  3250     }
  3251 
  3252   /* If realized faces have been removed, e.g. because of face
  3253      attribute changes of named faces, recompute them.  When running
  3254      in batch mode, the face cache of the initial frame is null.  If
  3255      we happen to get called, make a dummy face cache.  */
  3256   if (FRAME_FACE_CACHE (it->f) == NULL)
  3257     init_frame_faces (it->f);
  3258   if (FRAME_FACE_CACHE (it->f)->used == 0)
  3259     recompute_basic_faces (it->f);
  3260 
  3261   it->override_ascent = -1;
  3262 
  3263   /* Are control characters displayed as `^C'?  */
  3264   it->ctl_arrow_p = !NILP (BVAR (current_buffer, ctl_arrow));
  3265 
  3266   /* -1 means everything between a CR and the following line end
  3267      is invisible.  >0 means lines indented more than this value are
  3268      invisible.  */
  3269   it->selective = (FIXNUMP (BVAR (current_buffer, selective_display))
  3270                    ? (clip_to_bounds
  3271                       (-1, XFIXNUM (BVAR (current_buffer, selective_display)),
  3272                        PTRDIFF_MAX))
  3273                    : (!NILP (BVAR (current_buffer, selective_display))
  3274                       ? -1 : 0));
  3275   it->selective_display_ellipsis_p
  3276     = !NILP (BVAR (current_buffer, selective_display_ellipses));
  3277 
  3278   /* Display table to use.  */
  3279   it->dp = window_display_table (w);
  3280 
  3281   /* Are multibyte characters enabled in current_buffer?  */
  3282   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
  3283 
  3284   it->tab_width = SANE_TAB_WIDTH (current_buffer);
  3285 
  3286   /* Are lines in the display truncated?  */
  3287   if (TRUNCATE != 0)
  3288     it->line_wrap = TRUNCATE;
  3289   if (base_face_id == DEFAULT_FACE_ID
  3290       && !it->w->hscroll
  3291       && (WINDOW_FULL_WIDTH_P (it->w)
  3292           || NILP (Vtruncate_partial_width_windows)
  3293           || (FIXNUMP (Vtruncate_partial_width_windows)
  3294               /* PXW: Shall we do something about this?  */
  3295               && (XFIXNUM (Vtruncate_partial_width_windows)
  3296                   <= WINDOW_TOTAL_COLS (it->w))))
  3297       && NILP (BVAR (current_buffer, truncate_lines)))
  3298     it->line_wrap = NILP (BVAR (current_buffer, word_wrap))
  3299       ? WINDOW_WRAP : WORD_WRAP;
  3300 
  3301   /* Get dimensions of truncation and continuation glyphs.  These are
  3302      displayed as fringe bitmaps under X, but we need them for such
  3303      frames when the fringes are turned off.  The no_special_glyphs slot
  3304      of the iterator's frame, when set, suppresses their display - by
  3305      default for tooltip frames and when set via the 'no-special-glyphs'
  3306      frame parameter.  */
  3307 #ifdef HAVE_WINDOW_SYSTEM
  3308   if (!(FRAME_WINDOW_P (it->f) && it->f->no_special_glyphs))
  3309 #endif
  3310     {
  3311       if (it->line_wrap == TRUNCATE)
  3312         {
  3313           /* We will need the truncation glyph.  */
  3314           eassert (it->glyph_row == NULL);
  3315           produce_special_glyphs (it, IT_TRUNCATION);
  3316           it->truncation_pixel_width = it->pixel_width;
  3317         }
  3318       else
  3319         {
  3320           /* We will need the continuation glyph.  */
  3321           eassert (it->glyph_row == NULL);
  3322           produce_special_glyphs (it, IT_CONTINUATION);
  3323           it->continuation_pixel_width = it->pixel_width;
  3324         }
  3325     }
  3326 
  3327   /* Reset these values to zero because the produce_special_glyphs
  3328      above has changed them.  */
  3329   it->pixel_width = it->ascent = it->descent = 0;
  3330   it->phys_ascent = it->phys_descent = 0;
  3331 
  3332   /* Set this after getting the dimensions of truncation and
  3333      continuation glyphs, so that we don't produce glyphs when calling
  3334      produce_special_glyphs, above.  */
  3335   it->glyph_row = row;
  3336   it->area = TEXT_AREA;
  3337 
  3338   /* Get the dimensions of the display area.  The display area
  3339      consists of the visible window area plus a horizontally scrolled
  3340      part to the left of the window.  All x-values are relative to the
  3341      start of this total display area.  */
  3342   if (base_face_id != DEFAULT_FACE_ID)
  3343     {
  3344       /* Mode lines, menu bar in terminal frames.  */
  3345       it->first_visible_x = 0;
  3346       it->last_visible_x =
  3347         WINDOW_PIXEL_WIDTH (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
  3348     }
  3349   else
  3350     {
  3351       /* When hscrolling only the current line, don't apply the
  3352          hscroll here, it will be applied by display_line when it gets
  3353          to laying out the line showing point.  However, if the
  3354          window's min_hscroll is positive, the user specified a lower
  3355          bound for automatic hscrolling, so they expect the
  3356          non-current lines to obey that hscroll amount.  */
  3357       if (hscrolling_current_line_p (w))
  3358         {
  3359           if (w->min_hscroll > 0)
  3360             it->first_visible_x = w->min_hscroll * FRAME_COLUMN_WIDTH (it->f);
  3361           else
  3362             it->first_visible_x = 0;
  3363         }
  3364       else
  3365         it->first_visible_x =
  3366           window_hscroll_limited (w, it->f) * FRAME_COLUMN_WIDTH (it->f);
  3367 
  3368       body_width = window_box_width (w, TEXT_AREA);
  3369       if (!w->pseudo_window_p && !MINI_WINDOW_P (w)
  3370           && body_width != w->old_body_pixel_width)
  3371         FRAME_WINDOW_CHANGE (it->f) = true;
  3372       it->last_visible_x = it->first_visible_x + body_width;
  3373 
  3374       /* If we truncate lines, leave room for the truncation glyph(s) at
  3375          the right margin.  Otherwise, leave room for the continuation
  3376          glyph(s).  Done only if the window has no right fringe.  */
  3377       if (WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0)
  3378         {
  3379           if (it->line_wrap == TRUNCATE)
  3380             it->last_visible_x -= it->truncation_pixel_width;
  3381           else
  3382             it->last_visible_x -= it->continuation_pixel_width;
  3383         }
  3384 
  3385       it->tab_line_p = window_wants_tab_line (w);
  3386       it->header_line_p = window_wants_header_line (w);
  3387       body_height = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
  3388       it->current_y =  body_height + w->vscroll;
  3389     }
  3390 
  3391   /* Leave room for a border glyph.  */
  3392   if (!FRAME_WINDOW_P (it->f)
  3393       && !WINDOW_RIGHTMOST_P (it->w))
  3394     it->last_visible_x -= 1;
  3395 
  3396   it->last_visible_y = window_text_bottom_y (w);
  3397   body_height += it->last_visible_y;
  3398   if (!w->pseudo_window_p && !MINI_WINDOW_P (w)
  3399       && body_height != w->old_body_pixel_height)
  3400     FRAME_WINDOW_CHANGE (it->f) = true;
  3401 
  3402   /* For mode lines and alike, arrange for the first glyph having a
  3403      left box line if the face specifies a box.  */
  3404   if (base_face_id != DEFAULT_FACE_ID)
  3405     {
  3406       struct face *face;
  3407 
  3408       it->face_id = remapped_base_face_id;
  3409 
  3410       /* If we have a boxed mode line, make the first character appear
  3411          with a left box line.  */
  3412       face = FACE_FROM_ID_OR_NULL (it->f, remapped_base_face_id);
  3413       if (face && face->box != FACE_NO_BOX)
  3414         {
  3415           int box_thickness = face->box_vertical_line_width;
  3416           it->face_box_p = true;
  3417           it->start_of_box_run_p = true;
  3418           /* Make sure we will have enough horizontal space to add the
  3419              right box line at the end.  */
  3420           if (box_thickness > 0)
  3421             it->last_visible_x -= box_thickness;
  3422         }
  3423     }
  3424 
  3425   /* If a buffer position was specified, set the iterator there,
  3426      getting overlays and face properties from that position.  */
  3427   if (charpos >= BUF_BEG (current_buffer))
  3428     {
  3429       it->stop_charpos = charpos;
  3430       it->end_charpos = ZV;
  3431       eassert (charpos == BYTE_TO_CHAR (bytepos));
  3432       IT_CHARPOS (*it) = charpos;
  3433       IT_BYTEPOS (*it) = bytepos;
  3434 
  3435       /* We will rely on `reseat' to set this up properly, via
  3436          handle_face_prop.  */
  3437       it->face_id = it->base_face_id;
  3438 
  3439       it->start = it->current;
  3440       /* Do we need to reorder bidirectional text?  Not if this is a
  3441          unibyte buffer: by definition, none of the single-byte
  3442          characters are strong R2L, so no reordering is needed.  And
  3443          bidi.c doesn't support unibyte buffers anyway.  Also, don't
  3444          reorder while we are loading loadup.el, since the tables of
  3445          character properties needed for reordering are not yet
  3446          available.  */
  3447       it->bidi_p =
  3448         !redisplay__inhibit_bidi
  3449         && !NILP (BVAR (current_buffer, bidi_display_reordering))
  3450         && it->multibyte_p;
  3451 
  3452       /* If we are to reorder bidirectional text, init the bidi
  3453          iterator.  */
  3454       if (it->bidi_p)
  3455         {
  3456           /*  Since we don't know at this point whether there will be
  3457               any R2L lines in the window, we reserve space for
  3458               truncation/continuation glyphs even if only the left
  3459               fringe is absent.  */
  3460           if (base_face_id == DEFAULT_FACE_ID
  3461               && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0
  3462               && WINDOW_RIGHT_FRINGE_WIDTH (it->w) != 0)
  3463             {
  3464               if (it->line_wrap == TRUNCATE)
  3465                 it->last_visible_x -= it->truncation_pixel_width;
  3466               else
  3467                 it->last_visible_x -= it->continuation_pixel_width;
  3468             }
  3469           /* Note the paragraph direction that this buffer wants to
  3470              use.  */
  3471           if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
  3472                   Qleft_to_right))
  3473             it->paragraph_embedding = L2R;
  3474           else if (EQ (BVAR (current_buffer, bidi_paragraph_direction),
  3475                        Qright_to_left))
  3476             it->paragraph_embedding = R2L;
  3477           else
  3478             it->paragraph_embedding = NEUTRAL_DIR;
  3479           bidi_unshelve_cache (NULL, false);
  3480           bidi_init_it (charpos, IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
  3481                         &it->bidi_it);
  3482         }
  3483 
  3484       /* This is set only when long_line_optimizations_p is non-zero
  3485          for the current buffer.  */
  3486       it->medium_narrowing_begv = 0;
  3487 
  3488       /* Compute faces etc.  */
  3489       reseat (it, it->current.pos, true);
  3490     }
  3491 
  3492   CHECK_IT (it);
  3493 }
  3494 
  3495 /* How Emacs deals with long lines.
  3496 
  3497    (1) When a buffer is about to be (re)displayed, 'redisplay_window'
  3498    detects, with a heuristic, whether it contains long lines.
  3499 
  3500    This happens in 'redisplay_window' because it is only displaying
  3501    buffers with long lines that is problematic.  In other words, none
  3502    of the optimizations described below is ever used in buffers that
  3503    are never displayed.
  3504 
  3505    This happens with a heuristic, which checks whether a buffer
  3506    contains long lines, each time its contents have changed "enough"
  3507    between two redisplay cycles, because a buffer without long lines
  3508    can become a buffer with long lines at any time, for example after
  3509    a yank command, or after a replace command, or while the output of
  3510    an external process is inserted in a buffer.
  3511 
  3512    When Emacs has detected that a buffer contains long lines, the
  3513    buffer-local variable 'long_line_optimizations_p' (in 'struct
  3514    buffer') is set, and Emacs does not try to detect whether the
  3515    buffer does or does not contain long lines anymore.
  3516 
  3517    What a long line is depends on the variable 'long-line-threshold',
  3518    whose default value is 50000 (characters).
  3519 
  3520    (2) When a buffer with long lines is (re)displayed, the amount of
  3521    data that the display routines consider is, in a few well-chosen
  3522    places, limited with a temporary restriction, whose bounds are
  3523    calculated with the functions below.
  3524 
  3525    (2.1) 'get_small_narrowing_begv' is used to create a restriction
  3526    which starts a few hundred characters before point.  The exact
  3527    number of characters depends on the width of the window in which
  3528    the buffer is displayed.
  3529 
  3530    There is no corresponding 'get_small_narrowing_zv' function,
  3531    because it is not necessary to set the end limit of that
  3532    restriction.
  3533 
  3534    This restriction is used in four places, namely:
  3535    'back_to_previous_line_start' and 'move_it_vertically_backward'
  3536    (with the 'SET_WITH_NARROWED_BEGV' macro), and in
  3537    'composition_compute_stop_pos' and 'find_automatic_composition' (in
  3538    a conditional statement depending on 'long_line_optimizations_p').
  3539 
  3540    (2.2) 'get_medium_narrowing_begv' is used to create a restriction
  3541    which starts a few thousand characters before point.  The exact
  3542    number of characters depends on the size (width and height) of the
  3543    window in which the buffer is displayed.  For performance reasons,
  3544    the return value of that function is cached in 'struct it', in the
  3545    'medium_narrowing_begv' field.
  3546 
  3547    The corresponding function 'get_medium_narrowing_zv' (and
  3548    'medium_narrowing_zv' field in 'struct it') is not used to set the
  3549    end limit of the restriction, which is again unnecessary, but to
  3550    determine, in 'reseat', whether the iterator has moved far enough
  3551    from its original position, and whether the start position of the
  3552    restriction must be computed anew.
  3553 
  3554    This restriction is used in a single place:
  3555    'get_visually_first_element', with the 'SET_WITH_NARROWED_BEGV'
  3556    macro.
  3557 
  3558    (2.3) 'get_large_narrowing_begv' and 'get_large_narrowing_zv' are
  3559    used to create a restriction which starts a few hundred thousand
  3560    characters before point and ends a few hundred thousand characters
  3561    after point.  The size of that restriction depends on the variable
  3562    'long-line-optimizations-region-size', whose default value is
  3563    500000 (characters); it can be adjusted by a few hundred characters
  3564    depending on 'long-line-optimizations-bol-search-limit', whose
  3565    default value is 128 (characters).
  3566 
  3567    For performance reasons again, the return values of these functions
  3568    are stored in the 'large_narrowing_begv' and 'large_narrowing_zv'
  3569    fields in 'struct it'.
  3570 
  3571    The restriction defined by these values is used around three
  3572    low-level hooks: around 'fontification-functions', in
  3573    'handle_fontified_prop', and around 'pre-command-hook' and
  3574    'post-command-hook', in 'safe_run_hooks_maybe_narrowed', which is
  3575    called in 'command_loop_1'.  These restrictions are set around
  3576    these hooks with 'labeled_narrow_to_region'; the restrictions are
  3577    labeled, and cannot be removed with a call to 'widen', but can be
  3578    removed with 'without-restriction' with a :label argument.
  3579 */
  3580 
  3581 static int
  3582 get_narrowed_width (struct window *w)
  3583 {
  3584   /* In a character-only terminal, only one font size is used, so we
  3585      can use a smaller factor.  */
  3586   int fact = FRAME_WINDOW_P (XFRAME (w->frame)) ? 3 : 2;
  3587   /* If the window has no fringes (in a character-only terminal or in
  3588      a GUI frame without fringes), subtract 1 from the width for the
  3589      '\' line wrapping character.  */
  3590   int width = window_body_width (w, WINDOW_BODY_IN_CANONICAL_CHARS)
  3591     - ((WINDOW_RIGHT_FRINGE_WIDTH (w) == 0
  3592         || WINDOW_LEFT_FRINGE_WIDTH (w) == 0) ? 1 : 0);
  3593   return fact * max (1, width);
  3594 }
  3595 
  3596 static int
  3597 get_narrowed_len (struct window *w)
  3598 {
  3599   int height = window_body_height (w, WINDOW_BODY_IN_CANONICAL_CHARS);
  3600   return get_narrowed_width (w) * max (1, height);
  3601 }
  3602 
  3603 static ptrdiff_t
  3604 get_medium_narrowing_begv (struct window *w, ptrdiff_t pos)
  3605 {
  3606   int len = get_narrowed_len (w);
  3607   return max ((pos / len - 1) * len, BEGV);
  3608 }
  3609 
  3610 static ptrdiff_t
  3611 get_medium_narrowing_zv (struct window *w, ptrdiff_t pos)
  3612 {
  3613   int len = get_narrowed_len (w);
  3614   return min ((pos / len + 1) * len, ZV);
  3615 }
  3616 
  3617 /* Find the position of the last BOL before POS, unless it is too far
  3618    away.  The buffer portion in which the search occurs is gradually
  3619    enlarged: [POS-500..POS], [POS-5500..POS-500],
  3620    [POS-55500..POS-5500], and finally [POS-555500..POS-55500].  Return
  3621    BEGV-1 if no BOL was found in [POS-555500..POS].  */
  3622 static ptrdiff_t
  3623 get_nearby_bol_pos (ptrdiff_t pos)
  3624 {
  3625   ptrdiff_t start, pos_bytepos, cur, next, found, bol = BEGV - 1, init_pos = pos;
  3626   int dist;
  3627   for (dist = 500; dist <= 500000; dist *= 10)
  3628     {
  3629       pos_bytepos = pos == BEGV ? BEGV_BYTE : CHAR_TO_BYTE (pos);
  3630       start = pos - dist < BEGV ? BEGV : pos - dist;
  3631       for (cur = start; cur < pos; cur = next)
  3632         {
  3633           next = find_newline1 (cur, CHAR_TO_BYTE (cur),
  3634                                 pos, pos_bytepos,
  3635                                 1, &found, NULL, false);
  3636           if (found)
  3637             bol = next;
  3638           else
  3639             break;
  3640         }
  3641       if (bol >= BEGV || start == BEGV)
  3642         break;
  3643       else
  3644         pos = pos - dist < BEGV ? BEGV : pos - dist;
  3645     }
  3646   eassert (bol <= init_pos);
  3647   return bol;
  3648 }
  3649 
  3650 ptrdiff_t
  3651 get_small_narrowing_begv (struct window *w, ptrdiff_t pos)
  3652 {
  3653   int len = get_narrowed_width (w);
  3654   ptrdiff_t bol_pos = max (get_nearby_bol_pos (pos), BEGV);
  3655   return max (bol_pos + ((pos - bol_pos) / len - 1) * len, BEGV);
  3656 }
  3657 
  3658 ptrdiff_t
  3659 get_large_narrowing_begv (ptrdiff_t pos)
  3660 {
  3661   if (long_line_optimizations_region_size <= 0)
  3662     return BEGV;
  3663   int len = long_line_optimizations_region_size / 2;
  3664   int begv = max (pos - len, BEGV);
  3665   int limit = long_line_optimizations_bol_search_limit;
  3666   while (limit > 0)
  3667     {
  3668       if (begv == BEGV || FETCH_BYTE (CHAR_TO_BYTE (begv) - 1) == '\n')
  3669         return begv;
  3670       begv--;
  3671       limit--;
  3672     }
  3673   return begv;
  3674 }
  3675 
  3676 ptrdiff_t
  3677 get_large_narrowing_zv (ptrdiff_t pos)
  3678 {
  3679   if (long_line_optimizations_region_size <= 0)
  3680     return ZV;
  3681   int len = long_line_optimizations_region_size / 2;
  3682   return min (pos + len, ZV);
  3683 }
  3684 
  3685 static void
  3686 unwind_narrowed_begv (Lisp_Object point_min)
  3687 {
  3688   SET_BUF_BEGV (current_buffer, XFIXNUM (point_min));
  3689 }
  3690 
  3691 /* Set DST to EXPR.  When IT indicates that BEGV should temporarily be
  3692    updated to optimize display, evaluate EXPR with BEGV set to BV.  */
  3693 
  3694 #define SET_WITH_NARROWED_BEGV(IT,DST,EXPR,BV)                          \
  3695   do {                                                                  \
  3696     if (IT->medium_narrowing_begv)                                      \
  3697       {                                                                 \
  3698         specpdl_ref count = SPECPDL_INDEX ();                           \
  3699         record_unwind_protect (unwind_narrowed_begv, Fpoint_min ());    \
  3700         SET_BUF_BEGV (current_buffer, BV);                              \
  3701         DST = EXPR;                                                     \
  3702         unbind_to (count, Qnil);                                        \
  3703       }                                                                 \
  3704     else                                                                \
  3705       DST = EXPR;                                                       \
  3706   } while (0)
  3707 
  3708 /* Initialize IT for the display of window W with window start POS.  */
  3709 
  3710 void
  3711 start_display (struct it *it, struct window *w, struct text_pos pos)
  3712 {
  3713   struct glyph_row *row;
  3714   int first_vpos = window_wants_tab_line (w) + window_wants_header_line (w);
  3715 
  3716   row = w->desired_matrix->rows + first_vpos;
  3717   init_iterator (it, w, CHARPOS (pos), BYTEPOS (pos), row, DEFAULT_FACE_ID);
  3718   it->first_vpos = first_vpos;
  3719 
  3720   /* Don't reseat to previous visible line start if current start
  3721      position is in a string or image.  */
  3722   if (it->method == GET_FROM_BUFFER && it->line_wrap != TRUNCATE)
  3723     {
  3724       int first_y = it->current_y;
  3725 
  3726       /* If window start is not at a line start, skip forward to POS to
  3727          get the correct continuation lines width.  */
  3728       bool start_at_line_beg_p = (CHARPOS (pos) == BEGV
  3729                                   || FETCH_BYTE (BYTEPOS (pos) - 1) == '\n');
  3730       if (!start_at_line_beg_p)
  3731         {
  3732           int new_x;
  3733 
  3734           reseat_at_previous_visible_line_start (it);
  3735           move_it_to (it, CHARPOS (pos), -1, -1, -1, MOVE_TO_POS);
  3736 
  3737           new_x = it->current_x + it->pixel_width;
  3738 
  3739           /* If lines are continued, this line may end in the middle
  3740              of a multi-glyph character (e.g. a control character
  3741              displayed as \003, or in the middle of an overlay
  3742              string).  In this case move_it_to above will not have
  3743              taken us to the start of the continuation line but to the
  3744              end of the continued line.  */
  3745           if (it->current_x > 0
  3746               && it->line_wrap != TRUNCATE /* Lines are continued.  */
  3747               && (/* And glyph doesn't fit on the line.  */
  3748                   new_x > it->last_visible_x
  3749                   /* Or it fits exactly and we're on a window
  3750                      system frame.  */
  3751                   || (new_x == it->last_visible_x
  3752                       && FRAME_WINDOW_P (it->f)
  3753                       && ((it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  3754                           ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
  3755                           : WINDOW_RIGHT_FRINGE_WIDTH (it->w)))))
  3756             {
  3757               if ((it->current.dpvec_index >= 0
  3758                    || it->current.overlay_string_index >= 0)
  3759                   /* If we are on a newline from a display vector or
  3760                      overlay string, then we are already at the end of
  3761                      a screen line; no need to go to the next line in
  3762                      that case, as this line is not really continued.
  3763                      (If we do go to the next line, C-e will not DTRT.)  */
  3764                   && it->c != '\n')
  3765                 {
  3766                   set_iterator_to_next (it, true);
  3767                   move_it_in_display_line_to (it, -1, -1, 0);
  3768                 }
  3769 
  3770               it->continuation_lines_width += it->current_x;
  3771             }
  3772           /* If the character at POS is displayed via a display
  3773              vector, move_it_to above stops at the final glyph of
  3774              IT->dpvec.  To make the caller redisplay that character
  3775              again (a.k.a. start at POS), we need to reset the
  3776              dpvec_index to the beginning of IT->dpvec.  */
  3777           else if (it->current.dpvec_index >= 0)
  3778             it->current.dpvec_index = 0;
  3779 
  3780           /* We're starting a new display line, not affected by the
  3781              height of the continued line, so clear the appropriate
  3782              fields in the iterator structure.  */
  3783           it->max_ascent = it->max_descent = 0;
  3784           it->max_phys_ascent = it->max_phys_descent = 0;
  3785 
  3786           it->current_y = first_y;
  3787           it->vpos = 0;
  3788           it->current_x = it->hpos = 0;
  3789         }
  3790     }
  3791 }
  3792 
  3793 
  3794 /* Return true if POS is a position in ellipses displayed for invisible
  3795    text.  W is the window we display, for text property lookup.  */
  3796 
  3797 static bool
  3798 in_ellipses_for_invisible_text_p (struct display_pos *pos, struct window *w)
  3799 {
  3800   Lisp_Object prop, window;
  3801   bool ellipses_p = false;
  3802   ptrdiff_t charpos = CHARPOS (pos->pos);
  3803 
  3804   /* If POS specifies a position in a display vector, this might
  3805      be for an ellipsis displayed for invisible text.  We won't
  3806      get the iterator set up for delivering that ellipsis unless
  3807      we make sure that it gets aware of the invisible text.  */
  3808   if (pos->dpvec_index >= 0
  3809       && pos->overlay_string_index < 0
  3810       && CHARPOS (pos->string_pos) < 0
  3811       && charpos > BEGV
  3812       && (XSETWINDOW (window, w),
  3813           prop = Fget_char_property (make_fixnum (charpos),
  3814                                      Qinvisible, window),
  3815           TEXT_PROP_MEANS_INVISIBLE (prop) == 0))
  3816     {
  3817       prop = Fget_char_property (make_fixnum (charpos - 1), Qinvisible,
  3818                                  window);
  3819       ellipses_p = 2 == TEXT_PROP_MEANS_INVISIBLE (prop);
  3820     }
  3821 
  3822   return ellipses_p;
  3823 }
  3824 
  3825 
  3826 /* Initialize IT for stepping through current_buffer in window W,
  3827    starting at position POS that includes overlay string and display
  3828    vector/ control character translation position information.  Value
  3829    is false if there are overlay strings with newlines at POS.  */
  3830 
  3831 static bool
  3832 init_from_display_pos (struct it *it, struct window *w, struct display_pos *pos)
  3833 {
  3834   ptrdiff_t charpos = CHARPOS (pos->pos), bytepos = BYTEPOS (pos->pos);
  3835   int i;
  3836   bool overlay_strings_with_newlines = false;
  3837 
  3838   /* If POS specifies a position in a display vector, this might
  3839      be for an ellipsis displayed for invisible text.  We won't
  3840      get the iterator set up for delivering that ellipsis unless
  3841      we make sure that it gets aware of the invisible text.  */
  3842   if (in_ellipses_for_invisible_text_p (pos, w))
  3843     {
  3844       --charpos;
  3845       bytepos = 0;
  3846     }
  3847 
  3848   /* Keep in mind: the call to reseat in init_iterator skips invisible
  3849      text, so we might end up at a position different from POS.  This
  3850      is only a problem when POS is a row start after a newline and an
  3851      overlay starts there with an after-string, and the overlay has an
  3852      invisible property.  Since we don't skip invisible text in
  3853      display_line and elsewhere immediately after consuming the
  3854      newline before the row start, such a POS will not be in a string,
  3855      but the call to init_iterator below will move us to the
  3856      after-string.  */
  3857   init_iterator (it, w, charpos, bytepos, NULL, DEFAULT_FACE_ID);
  3858 
  3859   /* This only scans the current chunk -- it should scan all chunks.
  3860      However, OVERLAY_STRING_CHUNK_SIZE has been increased from 3 in 21.1
  3861      to 16 in 22.1 to make this a lesser problem.  */
  3862   for (i = 0; i < it->n_overlay_strings && i < OVERLAY_STRING_CHUNK_SIZE; ++i)
  3863     {
  3864       const char *s = SSDATA (it->overlay_strings[i]);
  3865       const char *e = s + SBYTES (it->overlay_strings[i]);
  3866 
  3867       while (s < e && *s != '\n')
  3868         ++s;
  3869 
  3870       if (s < e)
  3871         {
  3872           overlay_strings_with_newlines = true;
  3873           break;
  3874         }
  3875     }
  3876 
  3877   /* If position is within an overlay string, set up IT to the right
  3878      overlay string.  */
  3879   if (pos->overlay_string_index >= 0)
  3880     {
  3881       int relative_index;
  3882 
  3883       /* If the first overlay string happens to have a `display'
  3884          property for an image, the iterator will be set up for that
  3885          image, and we have to undo that setup first before we can
  3886          correct the overlay string index.  */
  3887       if (it->method == GET_FROM_IMAGE)
  3888         pop_it (it);
  3889 
  3890       /* We already have the first chunk of overlay strings in
  3891          IT->overlay_strings.  Load more until the one for
  3892          pos->overlay_string_index is in IT->overlay_strings.  */
  3893       if (pos->overlay_string_index >= OVERLAY_STRING_CHUNK_SIZE)
  3894         {
  3895           ptrdiff_t n = pos->overlay_string_index / OVERLAY_STRING_CHUNK_SIZE;
  3896           it->current.overlay_string_index = 0;
  3897           while (n--)
  3898             {
  3899               load_overlay_strings (it, 0);
  3900               it->current.overlay_string_index += OVERLAY_STRING_CHUNK_SIZE;
  3901             }
  3902         }
  3903 
  3904       it->current.overlay_string_index = pos->overlay_string_index;
  3905       relative_index = (it->current.overlay_string_index
  3906                         % OVERLAY_STRING_CHUNK_SIZE);
  3907       it->string = it->overlay_strings[relative_index];
  3908       eassert (STRINGP (it->string));
  3909       it->current.string_pos = pos->string_pos;
  3910       it->method = GET_FROM_STRING;
  3911       it->end_charpos = SCHARS (it->string);
  3912       /* Set up the bidi iterator for this overlay string.  */
  3913       if (it->bidi_p)
  3914         {
  3915           it->bidi_it.string.lstring = it->string;
  3916           it->bidi_it.string.s = NULL;
  3917           it->bidi_it.string.schars = SCHARS (it->string);
  3918           it->bidi_it.string.bufpos = it->overlay_strings_charpos;
  3919           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
  3920           it->bidi_it.string.unibyte = !it->multibyte_p;
  3921           it->bidi_it.w = it->w;
  3922           bidi_init_it (IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it),
  3923                         FRAME_WINDOW_P (it->f), &it->bidi_it);
  3924 
  3925           /* Synchronize the state of the bidi iterator with
  3926              pos->string_pos.  For any string position other than
  3927              zero, this will be done automagically when we resume
  3928              iteration over the string and get_visually_first_element
  3929              is called.  But if string_pos is zero, and the string is
  3930              to be reordered for display, we need to resync manually,
  3931              since it could be that the iteration state recorded in
  3932              pos ended at string_pos of 0 moving backwards in string.  */
  3933           if (CHARPOS (pos->string_pos) == 0)
  3934             {
  3935               get_visually_first_element (it);
  3936               if (IT_STRING_CHARPOS (*it) != 0)
  3937                 do {
  3938                   /* Paranoia.  */
  3939                   eassert (it->bidi_it.charpos < it->bidi_it.string.schars);
  3940                   bidi_move_to_visually_next (&it->bidi_it);
  3941                 } while (it->bidi_it.charpos != 0);
  3942             }
  3943           eassert (IT_STRING_CHARPOS (*it) == it->bidi_it.charpos
  3944                    && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos);
  3945         }
  3946     }
  3947 
  3948   if (CHARPOS (pos->string_pos) >= 0)
  3949     {
  3950       /* Recorded position is not in an overlay string, but in another
  3951          string.  This can only be a string from a `display' property.
  3952          IT should already be filled with that string.  */
  3953       it->current.string_pos = pos->string_pos;
  3954       eassert (STRINGP (it->string));
  3955       if (it->bidi_p)
  3956         bidi_init_it (IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it),
  3957                       FRAME_WINDOW_P (it->f), &it->bidi_it);
  3958     }
  3959 
  3960   /* Restore position in display vector translations, control
  3961      character translations or ellipses.  */
  3962   if (pos->dpvec_index >= 0)
  3963     {
  3964       if (it->dpvec == NULL)
  3965         get_next_display_element (it);
  3966       eassert (it->dpvec && it->current.dpvec_index == 0);
  3967       it->current.dpvec_index = pos->dpvec_index;
  3968     }
  3969 
  3970   CHECK_IT (it);
  3971   return !overlay_strings_with_newlines;
  3972 }
  3973 
  3974 
  3975 /* Initialize IT for stepping through current_buffer in window W
  3976    starting at ROW->start.  */
  3977 
  3978 static void
  3979 init_to_row_start (struct it *it, struct window *w, struct glyph_row *row)
  3980 {
  3981   init_from_display_pos (it, w, &row->start);
  3982   it->start = row->start;
  3983   it->continuation_lines_width = row->continuation_lines_width;
  3984   CHECK_IT (it);
  3985 }
  3986 
  3987 
  3988 /* Initialize IT for stepping through current_buffer in window W
  3989    starting in the line following ROW, i.e. starting at ROW->end.
  3990    Value is false if there are overlay strings with newlines at ROW's
  3991    end position, or if the following row begins with bidi-reordered
  3992    characters that could be composed.  */
  3993 
  3994 static bool
  3995 init_to_row_end (struct it *it, struct window *w, struct glyph_row *row)
  3996 {
  3997   bool success = false;
  3998 
  3999   if (init_from_display_pos (it, w, &row->end))
  4000     {
  4001       if (row->continued_p)
  4002         it->continuation_lines_width
  4003           = row->continuation_lines_width + row->pixel_width;
  4004       CHECK_IT (it);
  4005       /* Initializing IT in the presence of compositions in reordered
  4006          rows is tricky: row->end above will generally cause us to
  4007          start at position that is not the first one in the logical
  4008          order, and we might therefore miss the composition earlier in
  4009          the buffer that affects how glypsh are laid out in this row.
  4010          So we punt instead.  Note: the test below works because
  4011          get_next_display_element calls get_visually_first_element,
  4012          which calls composition_compute_stop_pos, which populates
  4013          it->cmp_it.  */
  4014       if (get_next_display_element (it)
  4015           && (it->bidi_it.scan_dir == -1 && it->cmp_it.id >= 0))
  4016         success = false;
  4017       else
  4018         success = true;
  4019     }
  4020 
  4021   return success;
  4022 }
  4023 
  4024 
  4025 
  4026 
  4027 /***********************************************************************
  4028                            Text properties
  4029  ***********************************************************************/
  4030 
  4031 /* Called when IT reaches IT->stop_charpos.  Handle text property and
  4032    overlay changes.  Set IT->stop_charpos to the next position where
  4033    to stop.  */
  4034 
  4035 static void
  4036 handle_stop (struct it *it)
  4037 {
  4038   enum prop_handled handled;
  4039   bool handle_overlay_change_p;
  4040   struct props *p;
  4041 
  4042   it->dpvec = NULL;
  4043   it->current.dpvec_index = -1;
  4044   handle_overlay_change_p = !it->ignore_overlay_strings_at_pos_p;
  4045   it->ellipsis_p = false;
  4046 
  4047   /* Use face of preceding text for ellipsis (if invisible) */
  4048   if (it->selective_display_ellipsis_p)
  4049     it->saved_face_id = it->face_id;
  4050 
  4051   /* Here's the description of the semantics of, and the logic behind,
  4052      the various HANDLED_* statuses:
  4053 
  4054      HANDLED_NORMALLY means the handler did its job, and the loop
  4055      should proceed to calling the next handler in order.
  4056 
  4057      HANDLED_RECOMPUTE_PROPS means the handler caused a significant
  4058      change in the properties and overlays at current position, so the
  4059      loop should be restarted, to re-invoke the handlers that were
  4060      already called.  This happens when fontification-functions were
  4061      called by handle_fontified_prop, and actually fontified
  4062      something.  Another case where HANDLED_RECOMPUTE_PROPS is
  4063      returned is when we discover overlay strings that need to be
  4064      displayed right away.  The loop below will continue for as long
  4065      as the status is HANDLED_RECOMPUTE_PROPS.
  4066 
  4067      HANDLED_RETURN means return immediately to the caller, to
  4068      continue iteration without calling any further handlers.  This is
  4069      used when we need to act on some property right away, for example
  4070      when we need to display the ellipsis or a replacing display
  4071      property, such as display string or image.
  4072 
  4073      HANDLED_OVERLAY_STRING_CONSUMED means an overlay string was just
  4074      consumed, and the handler switched to the next overlay string.
  4075      This signals the loop below to refrain from looking for more
  4076      overlays before all the overlay strings of the current overlay
  4077      are processed.
  4078 
  4079      Some of the handlers called by the loop push the iterator state
  4080      onto the stack (see 'push_it'), and arrange for the iteration to
  4081      continue with another object, such as an image, a display string,
  4082      or an overlay string.  In most such cases, it->stop_charpos is
  4083      set to the first character of the string, so that when the
  4084      iteration resumes, this function will immediately be called
  4085      again, to examine the properties at the beginning of the string.
  4086 
  4087      When a display or overlay string is exhausted, the iterator state
  4088      is popped (see 'pop_it'), and iteration continues with the
  4089      previous object.  Again, in many such cases this function is
  4090      called again to find the next position where properties might
  4091      change.  */
  4092 
  4093   do
  4094     {
  4095       handled = HANDLED_NORMALLY;
  4096 
  4097       /* Call text property handlers.  */
  4098       for (p = it_props; p->handler; ++p)
  4099         {
  4100           handled = p->handler (it);
  4101 
  4102           if (handled == HANDLED_RECOMPUTE_PROPS)
  4103             break;
  4104           else if (handled == HANDLED_RETURN)
  4105             {
  4106               /* We still want to show before and after strings from
  4107                  overlays even if the actual buffer text is replaced.  */
  4108               if (!handle_overlay_change_p
  4109                   || it->sp > 1
  4110                   /* Don't call get_overlay_strings_1 if we already
  4111                      have overlay strings loaded, because doing so
  4112                      will load them again and push the iterator state
  4113                      onto the stack one more time, which is not
  4114                      expected by the rest of the code that processes
  4115                      overlay strings.  */
  4116                   || (it->current.overlay_string_index < 0
  4117                       && !get_overlay_strings_1 (it, 0, false)))
  4118                 {
  4119                   if (it->ellipsis_p)
  4120                     setup_for_ellipsis (it, 0);
  4121                   /* When handling a display spec, we might load an
  4122                      empty string.  In that case, discard it here.  We
  4123                      used to discard it in handle_single_display_spec,
  4124                      but that causes get_overlay_strings_1, above, to
  4125                      ignore overlay strings that we must check.  */
  4126                   if (STRINGP (it->string) && !SCHARS (it->string))
  4127                     pop_it (it);
  4128                   return;
  4129                 }
  4130               else if (STRINGP (it->string) && !SCHARS (it->string))
  4131                 pop_it (it);
  4132               else
  4133                 {
  4134                   it->string_from_display_prop_p = false;
  4135                   it->from_disp_prop_p = false;
  4136                   handle_overlay_change_p = false;
  4137                 }
  4138               handled = HANDLED_RECOMPUTE_PROPS;
  4139               break;
  4140             }
  4141           else if (handled == HANDLED_OVERLAY_STRING_CONSUMED)
  4142             handle_overlay_change_p = false;
  4143         }
  4144 
  4145       if (handled != HANDLED_RECOMPUTE_PROPS)
  4146         {
  4147           /* Don't check for overlay strings below when set to deliver
  4148              characters from a display vector.  */
  4149           if (it->method == GET_FROM_DISPLAY_VECTOR)
  4150             handle_overlay_change_p = false;
  4151 
  4152           /* Handle overlay changes.
  4153              This sets HANDLED to HANDLED_RECOMPUTE_PROPS
  4154              if it finds overlays.  */
  4155           if (handle_overlay_change_p)
  4156             handled = handle_overlay_change (it);
  4157         }
  4158 
  4159       if (it->ellipsis_p)
  4160         {
  4161           setup_for_ellipsis (it, 0);
  4162           break;
  4163         }
  4164     }
  4165   while (handled == HANDLED_RECOMPUTE_PROPS);
  4166 
  4167   /* Determine where to stop next.  */
  4168   if (handled == HANDLED_NORMALLY)
  4169     compute_stop_pos (it);
  4170 }
  4171 
  4172 
  4173 /* Compute IT->stop_charpos from text property and overlay change
  4174    information for IT's current position.  */
  4175 
  4176 static void
  4177 compute_stop_pos (struct it *it)
  4178 {
  4179   register INTERVAL iv, next_iv;
  4180   Lisp_Object object, limit, position;
  4181   ptrdiff_t charpos, bytepos, cmp_limit_pos = -1;
  4182 
  4183   if (STRINGP (it->string))
  4184     {
  4185       /* Strings are usually short, so don't limit the search for
  4186          properties.  */
  4187       it->stop_charpos = it->end_charpos;
  4188       object = it->string;
  4189       limit = Qnil;
  4190       charpos = IT_STRING_CHARPOS (*it);
  4191       bytepos = IT_STRING_BYTEPOS (*it);
  4192     }
  4193   else
  4194     {
  4195       ptrdiff_t pos;
  4196 
  4197       /* If end_charpos is out of range for some reason, such as a
  4198          misbehaving display function, rationalize it (Bug#5984).  */
  4199       if (it->end_charpos > ZV)
  4200         it->end_charpos = ZV;
  4201       it->stop_charpos = it->end_charpos;
  4202 
  4203       /* If next overlay change is in front of the current stop pos
  4204          (which is IT->end_charpos), stop there.  Note: value of
  4205          next_overlay_change is point-max if no overlay change
  4206          follows.  */
  4207       charpos = IT_CHARPOS (*it);
  4208       bytepos = IT_BYTEPOS (*it);
  4209       pos = next_overlay_change (charpos);
  4210       if (pos < it->stop_charpos)
  4211         it->stop_charpos = pos;
  4212       /* If we are breaking compositions at point, stop at point.  */
  4213       if (!NILP (BVAR (current_buffer, enable_multibyte_characters))
  4214           && !NILP (Vauto_composition_mode)
  4215           && composition_break_at_point
  4216           && charpos < PT && PT < it->stop_charpos)
  4217         it->stop_charpos = PT;
  4218 
  4219       /* Set up variables for computing the stop position from text
  4220          property changes.  */
  4221       XSETBUFFER (object, current_buffer);
  4222       pos = charpos + TEXT_PROP_DISTANCE_LIMIT;
  4223       /* Make sure the above arbitrary limit position is not in the
  4224          middle of composable text, so we don't break compositions by
  4225          submitting the composable text to the shaper in separate
  4226          chunks.  We play safe here by assuming that only SPC, TAB,
  4227          FF, and NL cannot be in some composition; in particular, most
  4228          ASCII punctuation characters could be composed into ligatures.  */
  4229       if (!composition_break_at_point
  4230           && !NILP (BVAR (current_buffer, enable_multibyte_characters))
  4231           && !NILP (Vauto_composition_mode))
  4232         {
  4233           ptrdiff_t endpos = charpos + 10 * TEXT_PROP_DISTANCE_LIMIT;
  4234           bool found = false;
  4235 
  4236           if (pos > ZV)
  4237             pos = ZV;
  4238           if (endpos > ZV)
  4239             endpos = ZV;
  4240           ptrdiff_t bpos = CHAR_TO_BYTE (pos);
  4241           while (pos < endpos)
  4242             {
  4243               int ch = fetch_char_advance_no_check (&pos, &bpos);
  4244               if (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\f')
  4245                 {
  4246                   found = true;
  4247                   break;
  4248                 }
  4249             }
  4250           if (found)
  4251             {
  4252               pos--;
  4253               cmp_limit_pos = pos;
  4254             }
  4255           else if (it->stop_charpos < endpos)
  4256             pos = it->stop_charpos;
  4257           else
  4258             {
  4259               /* Give up and use the original arbitrary limit.  */
  4260               pos = charpos + TEXT_PROP_DISTANCE_LIMIT;
  4261             }
  4262         }
  4263       limit = make_fixnum (pos);
  4264     }
  4265 
  4266   /* Get the interval containing IT's position.  Value is a null
  4267      interval if there isn't such an interval.  */
  4268   position = make_fixnum (charpos);
  4269   iv = validate_interval_range (object, &position, &position, false);
  4270   if (iv)
  4271     {
  4272       Lisp_Object values_here[LAST_PROP_IDX];
  4273       struct props *p;
  4274 
  4275       /* Get properties here.  */
  4276       for (p = it_props; p->handler; ++p)
  4277         values_here[p->idx] = textget (iv->plist,
  4278                                        builtin_lisp_symbol (p->name));
  4279 
  4280       /* Look for an interval following iv that has different
  4281          properties.  */
  4282       for (next_iv = next_interval (iv);
  4283            (next_iv
  4284             && (NILP (limit)
  4285                 || XFIXNAT (limit) > next_iv->position));
  4286            next_iv = next_interval (next_iv))
  4287         {
  4288           for (p = it_props; p->handler; ++p)
  4289             {
  4290               Lisp_Object new_value = textget (next_iv->plist,
  4291                                                builtin_lisp_symbol (p->name));
  4292               if (!EQ (values_here[p->idx], new_value))
  4293                 break;
  4294             }
  4295 
  4296           if (p->handler)
  4297             break;
  4298         }
  4299 
  4300       if (next_iv)
  4301         {
  4302           if (FIXNUMP (limit)
  4303               && next_iv->position >= XFIXNAT (limit))
  4304             /* No text property change up to limit.  */
  4305             it->stop_charpos = min (XFIXNAT (limit), it->stop_charpos);
  4306           else
  4307             /* Text properties change in next_iv.  */
  4308             it->stop_charpos = min (it->stop_charpos, next_iv->position);
  4309         }
  4310     }
  4311 
  4312   if (it->cmp_it.id < 0
  4313       && (STRINGP (it->string)
  4314           || ((!it->bidi_p || it->bidi_it.scan_dir >= 0)
  4315               && it->cmp_it.stop_pos <= IT_CHARPOS (*it))))
  4316     {
  4317       ptrdiff_t stoppos = it->end_charpos;
  4318 
  4319       /* If we found, above, a buffer position that cannot be part of
  4320          an automatic composition, limit the search of composable
  4321          characters to that position.  */
  4322       if (it->bidi_p && it->bidi_it.scan_dir < 0)
  4323         stoppos = -1;
  4324       else if (cmp_limit_pos > 0)
  4325         stoppos = cmp_limit_pos;
  4326       /* Force composition_compute_stop_pos avoid the costly search
  4327          for static compositions, since those were already found by
  4328          looking at text properties, above.  */
  4329       composition_compute_stop_pos (&it->cmp_it, charpos, bytepos,
  4330                                     stoppos, it->string, false);
  4331     }
  4332 
  4333   eassert (STRINGP (it->string)
  4334            || (it->stop_charpos >= BEGV
  4335                && it->stop_charpos >= IT_CHARPOS (*it)));
  4336 }
  4337 
  4338 /* How many characters forward to search for a display property or
  4339    display string.  Searching too far forward makes the bidi display
  4340    sluggish, especially in small windows.  */
  4341 #define MAX_DISP_SCAN 250
  4342 
  4343 /* Return the character position of a display string at or after
  4344    position specified by POSITION.  If no display string exists at or
  4345    after POSITION, return ZV.  A display string is either an overlay
  4346    with `display' property whose value is a string, or a `display'
  4347    text property whose value is a string.  STRING is data about the
  4348    string to iterate; if STRING->lstring is nil, we are iterating a
  4349    buffer.  FRAME_WINDOW_P is true when we are displaying a window
  4350    on a GUI frame.  DISP_PROP is set to zero if we searched
  4351    MAX_DISP_SCAN characters forward without finding any display
  4352    strings, non-zero otherwise.  It is set to 2 if the display string
  4353    uses any kind of `(space ...)' spec that will produce a stretch of
  4354    white space in the text area.  */
  4355 ptrdiff_t
  4356 compute_display_string_pos (struct text_pos *position,
  4357                             struct bidi_string_data *string,
  4358                             struct window *w,
  4359                             bool frame_window_p, int *disp_prop)
  4360 {
  4361   /* OBJECT = nil means current buffer.  */
  4362   Lisp_Object object, object1;
  4363   Lisp_Object pos, spec, limpos;
  4364   bool string_p = string && (STRINGP (string->lstring) || string->s);
  4365   ptrdiff_t eob = string_p ? string->schars : ZV;
  4366   ptrdiff_t begb = string_p ? 0 : BEGV;
  4367   ptrdiff_t bufpos, charpos = CHARPOS (*position);
  4368   ptrdiff_t lim =
  4369     (charpos < eob - MAX_DISP_SCAN) ? charpos + MAX_DISP_SCAN : eob;
  4370   struct text_pos tpos;
  4371   int rv = 0;
  4372 
  4373   if (string && STRINGP (string->lstring))
  4374     object1 = object = string->lstring;
  4375   else if (w && !string_p)
  4376     {
  4377       XSETWINDOW (object, w);
  4378       object1 = Qnil;
  4379     }
  4380   else
  4381     object1 = object = Qnil;
  4382 
  4383   *disp_prop = 1;
  4384 
  4385   if (charpos >= eob
  4386       /* We don't support display properties whose values are strings
  4387          that have display string properties.  */
  4388       || string->from_disp_str
  4389       /* C strings cannot have display properties.  */
  4390       || (string->s && !STRINGP (object)))
  4391     {
  4392       *disp_prop = 0;
  4393       return eob;
  4394     }
  4395 
  4396   /* If the character at CHARPOS is where the display string begins,
  4397      return CHARPOS.  */
  4398   pos = make_fixnum (charpos);
  4399   if (STRINGP (object))
  4400     bufpos = string->bufpos;
  4401   else
  4402     bufpos = charpos;
  4403   tpos = *position;
  4404   if (!NILP (spec = Fget_char_property (pos, Qdisplay, object))
  4405       && (charpos <= begb
  4406           || !EQ (Fget_char_property (make_fixnum (charpos - 1), Qdisplay,
  4407                                       object),
  4408                   spec))
  4409       && (rv = handle_display_spec (NULL, spec, object1, Qnil, &tpos, bufpos,
  4410                                     frame_window_p)))
  4411     {
  4412       if (rv == 2)
  4413         *disp_prop = 2;
  4414       return charpos;
  4415     }
  4416 
  4417   /* Look forward for the first character with a `display' property
  4418      that will replace the underlying text when displayed.  */
  4419   limpos = make_fixnum (lim);
  4420   do {
  4421     pos = Fnext_single_char_property_change (pos, Qdisplay, object1, limpos);
  4422     CHARPOS (tpos) = XFIXNAT (pos);
  4423     if (CHARPOS (tpos) >= lim)
  4424       {
  4425         *disp_prop = 0;
  4426         break;
  4427       }
  4428     if (STRINGP (object))
  4429       BYTEPOS (tpos) = string_char_to_byte (object, CHARPOS (tpos));
  4430     else
  4431       BYTEPOS (tpos) = CHAR_TO_BYTE (CHARPOS (tpos));
  4432     spec = Fget_char_property (pos, Qdisplay, object);
  4433     if (!STRINGP (object))
  4434       bufpos = CHARPOS (tpos);
  4435   } while (NILP (spec)
  4436            || !(rv = handle_display_spec (NULL, spec, object1, Qnil, &tpos,
  4437                                           bufpos, frame_window_p)));
  4438   if (rv == 2)
  4439     *disp_prop = 2;
  4440 
  4441   return CHARPOS (tpos);
  4442 }
  4443 
  4444 /* Return the character position of the end of the display string that
  4445    started at CHARPOS.  If there's no display string at CHARPOS,
  4446    return -1.  A display string is either an overlay with `display'
  4447    property whose value is a string or a `display' text property whose
  4448    value is a string.  */
  4449 ptrdiff_t
  4450 compute_display_string_end (ptrdiff_t charpos, struct bidi_string_data *string)
  4451 {
  4452   /* OBJECT = nil means current buffer.  */
  4453   Lisp_Object object =
  4454     (string && STRINGP (string->lstring)) ? string->lstring : Qnil;
  4455   Lisp_Object pos = make_fixnum (charpos);
  4456   ptrdiff_t eob =
  4457     (STRINGP (object) || (string && string->s)) ? string->schars : ZV;
  4458 
  4459   if (charpos >= eob || (string->s && !STRINGP (object)))
  4460     return eob;
  4461 
  4462   /* It could happen that the display property or overlay was removed
  4463      since we found it in compute_display_string_pos above.  One way
  4464      this can happen is if JIT font-lock was called (through
  4465      handle_fontified_prop), and jit-lock-functions remove text
  4466      properties or overlays from the portion of buffer that includes
  4467      CHARPOS.  Muse mode is known to do that, for example.  In this
  4468      case, we return -1 to the caller, to signal that no display
  4469      string is actually present at CHARPOS.  See bidi_fetch_char for
  4470      how this is handled.
  4471 
  4472      An alternative would be to never look for display properties past
  4473      it->stop_charpos.  But neither compute_display_string_pos nor
  4474      bidi_fetch_char that calls it know or care where the next
  4475      stop_charpos is.  */
  4476   if (NILP (Fget_char_property (pos, Qdisplay, object)))
  4477     return -1;
  4478 
  4479   /* Look forward for the first character where the `display' property
  4480      changes.  */
  4481   pos = Fnext_single_char_property_change (pos, Qdisplay, object, Qnil);
  4482 
  4483   return XFIXNAT (pos);
  4484 }
  4485 
  4486 
  4487 
  4488 /***********************************************************************
  4489                             Fontification
  4490  ***********************************************************************/
  4491 
  4492 /* Handle changes in the `fontified' property of the current buffer by
  4493    calling hook functions from Qfontification_functions to fontify
  4494    regions of text.  */
  4495 
  4496 static enum prop_handled
  4497 handle_fontified_prop (struct it *it)
  4498 {
  4499   Lisp_Object prop, pos;
  4500   enum prop_handled handled = HANDLED_NORMALLY;
  4501 
  4502   if (!NILP (Vmemory_full))
  4503     return handled;
  4504 
  4505   /* Get the value of the `fontified' property at IT's current buffer
  4506      position.  (The `fontified' property doesn't have a special
  4507      meaning in strings.)  If the value is nil, call functions from
  4508      Qfontification_functions.  */
  4509   if (!STRINGP (it->string)
  4510       && it->s == NULL
  4511       && !NILP (Vfontification_functions)
  4512       && !(input_was_pending && redisplay_skip_fontification_on_input)
  4513       && !NILP (Vrun_hooks)
  4514       && (pos = make_fixnum (IT_CHARPOS (*it)),
  4515           prop = Fget_char_property (pos, Qfontified, Qnil),
  4516           /* Ignore the special cased nil value always present at EOB since
  4517              no amount of fontifying will be able to change it.  */
  4518           NILP (prop) && IT_CHARPOS (*it) < Z))
  4519     {
  4520       specpdl_ref count = SPECPDL_INDEX ();
  4521       Lisp_Object val;
  4522       struct buffer *obuf = current_buffer;
  4523       ptrdiff_t begv = BEGV, zv = ZV;
  4524       bool old_clip_changed = current_buffer->clip_changed;
  4525       bool saved_inhibit_flag = it->f->inhibit_clear_image_cache;
  4526 
  4527       val = Vfontification_functions;
  4528       specbind (Qfontification_functions, Qnil);
  4529 
  4530       eassert (it->end_charpos == ZV);
  4531 
  4532       if (current_buffer->long_line_optimizations_p
  4533           && long_line_optimizations_region_size > 0)
  4534         {
  4535           ptrdiff_t begv = it->large_narrowing_begv;
  4536           ptrdiff_t zv = it->large_narrowing_zv;
  4537           ptrdiff_t charpos = IT_CHARPOS (*it);
  4538           if (charpos < begv || charpos > zv)
  4539             {
  4540               begv = get_large_narrowing_begv (charpos);
  4541               zv = get_large_narrowing_zv (charpos);
  4542             }
  4543           if (begv != BEG || zv != Z)
  4544             labeled_narrow_to_region (make_fixnum (begv), make_fixnum (zv),
  4545                                       Qlong_line_optimizations_in_fontification_functions);
  4546         }
  4547 
  4548       /* Don't allow Lisp that runs from 'fontification-functions'
  4549          clear our face and image caches behind our back.  */
  4550       it->f->inhibit_clear_image_cache = true;
  4551 
  4552       if (!CONSP (val) || EQ (XCAR (val), Qlambda))
  4553         safe_call1 (val, pos);
  4554       else
  4555         {
  4556           Lisp_Object fns, fn;
  4557 
  4558           fns = Qnil;
  4559 
  4560           for (; CONSP (val); val = XCDR (val))
  4561             {
  4562               fn = XCAR (val);
  4563 
  4564               if (EQ (fn, Qt))
  4565                 {
  4566                   /* A value of t indicates this hook has a local
  4567                      binding; it means to run the global binding too.
  4568                      In a global value, t should not occur.  If it
  4569                      does, we must ignore it to avoid an endless
  4570                      loop.  */
  4571                   for (fns = Fdefault_value (Qfontification_functions);
  4572                        CONSP (fns);
  4573                        fns = XCDR (fns))
  4574                     {
  4575                       fn = XCAR (fns);
  4576                       if (!EQ (fn, Qt))
  4577                         safe_call1 (fn, pos);
  4578                     }
  4579                 }
  4580               else
  4581                 safe_call1 (fn, pos);
  4582             }
  4583         }
  4584 
  4585       it->f->inhibit_clear_image_cache = saved_inhibit_flag;
  4586       unbind_to (count, Qnil);
  4587 
  4588       /* Fontification functions routinely call `save-restriction'.
  4589          Normally, this tags clip_changed, which can confuse redisplay
  4590          (see discussion in Bug#6671).  Since we don't perform any
  4591          special handling of fontification changes in the case where
  4592          `save-restriction' isn't called, there's no point doing so in
  4593          this case either.  So, if the buffer's restrictions are
  4594          actually left unchanged, reset clip_changed.  */
  4595       if (obuf == current_buffer)
  4596         {
  4597           if (begv == BEGV && zv == ZV)
  4598             current_buffer->clip_changed = old_clip_changed;
  4599         }
  4600       /* There isn't much we can reasonably do to protect against
  4601          misbehaving fontification, but here's a fig leaf.  */
  4602       else if (BUFFER_LIVE_P (obuf))
  4603         set_buffer_internal_1 (obuf);
  4604 
  4605       /* The fontification code may have added/removed text.
  4606          It could do even a lot worse, but let's at least protect against
  4607          the most obvious case where only the text past `pos' gets changed',
  4608          as is/was done in grep.el where some escapes sequences are turned
  4609          into face properties (bug#7876).  */
  4610       it->end_charpos = ZV;
  4611 
  4612       /* Return HANDLED_RECOMPUTE_PROPS only if function fontified
  4613          something.  This avoids an endless loop if they failed to
  4614          fontify the text for which reason ever.  */
  4615       if (!NILP (Fget_char_property (pos, Qfontified, Qnil)))
  4616         handled = HANDLED_RECOMPUTE_PROPS;
  4617     }
  4618 
  4619   return handled;
  4620 }
  4621 
  4622 
  4623 
  4624 /***********************************************************************
  4625                                 Faces
  4626  ***********************************************************************/
  4627 
  4628 static int
  4629 face_at_pos (const struct it *it, enum lface_attribute_index attr_filter)
  4630 {
  4631   ptrdiff_t next_stop;
  4632 
  4633   if (!STRINGP (it->string))
  4634     {
  4635       return face_at_buffer_position (it->w,
  4636                                       IT_CHARPOS (*it),
  4637                                       &next_stop,
  4638                                       (IT_CHARPOS (*it)
  4639                                        + TEXT_PROP_DISTANCE_LIMIT),
  4640                                       false, it->base_face_id,
  4641                                       attr_filter);
  4642     }
  4643   else
  4644     {
  4645       int base_face_id;
  4646       ptrdiff_t bufpos;
  4647       int i;
  4648       Lisp_Object from_overlay
  4649         = (it->current.overlay_string_index >= 0
  4650            ? it->string_overlays[it->current.overlay_string_index
  4651                                  % OVERLAY_STRING_CHUNK_SIZE]
  4652            : Qnil);
  4653 
  4654       /* See if we got to this string directly or indirectly from
  4655          an overlay property.  That includes the before-string or
  4656          after-string of an overlay, strings in display properties
  4657          provided by an overlay, their text properties, etc.
  4658 
  4659          FROM_OVERLAY is the overlay that brought us here, or nil if none.  */
  4660       if (! NILP (from_overlay))
  4661         for (i = it->sp - 1; i >= 0; i--)
  4662           {
  4663             if (it->stack[i].current.overlay_string_index >= 0)
  4664               from_overlay
  4665                 = it->string_overlays[it->stack[i].current.overlay_string_index
  4666                                       % OVERLAY_STRING_CHUNK_SIZE];
  4667             else if (! NILP (it->stack[i].from_overlay))
  4668               from_overlay = it->stack[i].from_overlay;
  4669 
  4670             if (!NILP (from_overlay))
  4671               break;
  4672           }
  4673 
  4674       if (! NILP (from_overlay))
  4675         {
  4676           bufpos = IT_CHARPOS (*it);
  4677           /* For a string from an overlay, the base face depends
  4678              only on text properties and ignores overlays.  */
  4679           base_face_id
  4680             = face_for_overlay_string (it->w,
  4681                                        IT_CHARPOS (*it),
  4682                                        &next_stop,
  4683                                        (IT_CHARPOS (*it)
  4684                                         + TEXT_PROP_DISTANCE_LIMIT),
  4685                                        false,
  4686                                        from_overlay, attr_filter);
  4687         }
  4688       else
  4689         {
  4690           bufpos = 0;
  4691 
  4692           /* For strings from a `display' property, use the face at
  4693              IT's current buffer position as the base face to merge
  4694              with, so that overlay strings appear in the same face as
  4695              surrounding text, unless they specify their own faces.
  4696              For strings from wrap-prefix and line-prefix properties,
  4697              use the default face, possibly remapped via
  4698              Vface_remapping_alist.  */
  4699           /* Note that the fact that we use the face at _buffer_
  4700              position means that a 'display' property on an overlay
  4701              string will not inherit the face of that overlay string,
  4702              but will instead revert to the face of buffer text
  4703              covered by the overlay.  This is visible, e.g., when the
  4704              overlay specifies a box face, but neither the buffer nor
  4705              the display string do.  This sounds like a design bug,
  4706              but Emacs always did that since v21.1, so changing that
  4707              might be a big deal.  */
  4708           base_face_id = it->string_from_prefix_prop_p
  4709             ? (!NILP (Vface_remapping_alist)
  4710                ? lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID)
  4711                : DEFAULT_FACE_ID)
  4712             : underlying_face_id (it);
  4713         }
  4714 
  4715       return face_at_string_position (it->w,
  4716                                       it->string,
  4717                                       IT_STRING_CHARPOS (*it),
  4718                                       bufpos,
  4719                                       &next_stop,
  4720                                       base_face_id, false,
  4721                                       attr_filter);
  4722     } /* !STRINGP (it->string) */
  4723 }
  4724 
  4725 
  4726 /* Set up iterator IT from face properties at its current position.
  4727    Called from handle_stop.  */
  4728 static enum prop_handled
  4729 handle_face_prop (struct it *it)
  4730 {
  4731   specpdl_ref count = SPECPDL_INDEX ();
  4732   /* Don't allow the user to quit out of face-merging code, in case
  4733      this is called when redisplaying a non-selected window, with
  4734      point temporarily moved to window-point.  */
  4735   specbind (Qinhibit_quit, Qt);
  4736   const int new_face_id = face_at_pos (it, 0);
  4737   unbind_to (count, Qnil);
  4738 
  4739 
  4740   /* Is this a start of a run of characters with box face?
  4741      Caveat: this can be called for a freshly initialized
  4742      iterator; face_id is -1 in this case.  We know that the new
  4743      face will not change until limit, i.e. if the new face has a
  4744      box, all characters up to limit will have one.  But, as
  4745      usual, we don't know whether limit is really the end.  */
  4746   if (new_face_id != it->face_id)
  4747     {
  4748       struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
  4749       /* If it->face_id is -1, old_face below will be NULL, see
  4750          the definition of FACE_FROM_ID_OR_NULL.  This will happen
  4751          if this is the initial call that gets the face.  */
  4752       struct face *old_face = FACE_FROM_ID_OR_NULL (it->f, it->face_id);
  4753 
  4754       /* If the value of face_id of the iterator is -1, we have to
  4755          look in front of IT's position and see whether there is a
  4756          face there that's different from new_face_id.  */
  4757       if (!STRINGP (it->string)
  4758           && !old_face
  4759           && IT_CHARPOS (*it) > BEG)
  4760         {
  4761           const int prev_face_id = face_before_it_pos (it);
  4762 
  4763           old_face = FACE_FROM_ID_OR_NULL (it->f, prev_face_id);
  4764         }
  4765 
  4766       /* If the new face has a box, but the old face does not,
  4767          this is the start of a run of characters with box face,
  4768          i.e. this character has a shadow on the left side.  */
  4769       it->face_id = new_face_id;
  4770       /* Don't reset the start_of_box_run_p flag, only set it if
  4771          needed.  */
  4772       if (!(it->start_of_box_run_p && old_face && old_face->box))
  4773         it->start_of_box_run_p = (new_face->box != FACE_NO_BOX
  4774                                   && (old_face == NULL || !old_face->box));
  4775       it->face_box_p = new_face->box != FACE_NO_BOX;
  4776     }
  4777 
  4778   return HANDLED_NORMALLY;
  4779 }
  4780 
  4781 
  4782 /* Return the ID of the face ``underlying'' IT's current position,
  4783    which is in a string.  If the iterator is associated with a
  4784    buffer, return the face at IT's current buffer position.
  4785    Otherwise, use the iterator's base_face_id.  */
  4786 
  4787 static int
  4788 underlying_face_id (const struct it *it)
  4789 {
  4790   int face_id = it->base_face_id, i;
  4791 
  4792   eassert (STRINGP (it->string));
  4793 
  4794   for (i = it->sp - 1; i >= 0; --i)
  4795     if (NILP (it->stack[i].string))
  4796       face_id = it->stack[i].face_id;
  4797 
  4798   return face_id;
  4799 }
  4800 
  4801 
  4802 /* Compute the face one character before or after the current position
  4803    of IT, in the visual order.  BEFORE_P means get the face
  4804    in front (to the left in L2R paragraphs, to the right in R2L
  4805    paragraphs) of IT's screen position.  Value is the ID of the face.  */
  4806 
  4807 static int
  4808 face_before_or_after_it_pos (struct it *it, bool before_p)
  4809 {
  4810   int face_id, limit;
  4811   ptrdiff_t next_check_charpos;
  4812   struct it it_copy;
  4813   void *it_copy_data = NULL;
  4814 
  4815   eassert (it->s == NULL);
  4816 
  4817   if (STRINGP (it->string))
  4818     {
  4819       ptrdiff_t bufpos, charpos;
  4820       int base_face_id;
  4821 
  4822       /* No face change past the end of the string (for the case we
  4823          are padding with spaces).  No face change before the string
  4824          start.  Ignore face changes before the first visible
  4825          character on this display line.  */
  4826       if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string)
  4827           || (IT_STRING_CHARPOS (*it) == 0 && before_p)
  4828           || it->current_x <= it->first_visible_x)
  4829         return it->face_id;
  4830 
  4831       if (!it->bidi_p)
  4832         {
  4833           /* Set charpos to the position before or after IT's current
  4834              position, in the logical order, which in the non-bidi
  4835              case is the same as the visual order.  */
  4836           if (before_p)
  4837             charpos = IT_STRING_CHARPOS (*it) - 1;
  4838           else if (it->what == IT_COMPOSITION)
  4839             /* For composition, we must check the character after the
  4840                composition.  */
  4841             charpos = IT_STRING_CHARPOS (*it) + it->cmp_it.nchars;
  4842           else
  4843             charpos = IT_STRING_CHARPOS (*it) + 1;
  4844         }
  4845       else
  4846         {
  4847           /* With bidi iteration, the character before the current in
  4848              the visual order cannot be found by simple iteration,
  4849              because "reverse" reordering is not supported.  Instead,
  4850              we need to start from the string beginning and go all the
  4851              way to the current string position, remembering the
  4852              visually-previous position.  We need to start from the
  4853              string beginning for the character after the current as
  4854              well, since the iterator state in IT may have been
  4855              pushed, and the bidi cache is no longer coherent with the
  4856              string's text.  */
  4857           SAVE_IT (it_copy, *it, it_copy_data);
  4858           IT_STRING_CHARPOS (it_copy) = 0;
  4859           bidi_init_it (0, 0, FRAME_WINDOW_P (it_copy.f), &it_copy.bidi_it);
  4860           it_copy.bidi_it.scan_dir = 0;
  4861 
  4862           do
  4863             {
  4864               charpos = it_copy.bidi_it.charpos;
  4865               if (charpos >= SCHARS (it->string))
  4866                 break;
  4867               bidi_move_to_visually_next (&it_copy.bidi_it);
  4868             }
  4869           while (it_copy.bidi_it.charpos != IT_STRING_CHARPOS (*it));
  4870 
  4871           if (!before_p)
  4872             {
  4873               /* Set charpos to the string position of the character
  4874                  that comes after IT's current position in the visual
  4875                  order.  */
  4876               int n = (it->what == IT_COMPOSITION ? it->cmp_it.nchars : 1);
  4877               /* If this is the first string character,
  4878                  bidi_move_to_visually_next will deliver character at
  4879                  current position without moving, so we need to enlarge N.  */
  4880               if (it_copy.bidi_it.first_elt)
  4881                 n++;
  4882               while (n--)
  4883                 bidi_move_to_visually_next (&it_copy.bidi_it);
  4884 
  4885               charpos = it_copy.bidi_it.charpos;
  4886             }
  4887 
  4888           RESTORE_IT (it, it, it_copy_data);
  4889         }
  4890       eassert (0 <= charpos && charpos <= SCHARS (it->string));
  4891 
  4892       if (it->current.overlay_string_index >= 0)
  4893         bufpos = IT_CHARPOS (*it);
  4894       else
  4895         bufpos = 0;
  4896 
  4897       base_face_id = underlying_face_id (it);
  4898 
  4899       /* Get the face for ASCII, or unibyte.  */
  4900       face_id = face_at_string_position (it->w, it->string, charpos,
  4901                                          bufpos, &next_check_charpos,
  4902                                          base_face_id, false, 0);
  4903 
  4904       /* Correct the face for charsets different from ASCII.  Do it
  4905          for the multibyte case only.  The face returned above is
  4906          suitable for unibyte text if IT->string is unibyte.  */
  4907       if (STRING_MULTIBYTE (it->string))
  4908         {
  4909           struct text_pos pos1 = string_pos (charpos, it->string);
  4910           const unsigned char *p = SDATA (it->string) + BYTEPOS (pos1);
  4911           struct face *face = FACE_FROM_ID (it->f, face_id);
  4912           int len, c = check_char_and_length (p, &len);
  4913           face_id = FACE_FOR_CHAR (it->f, face, c, charpos, it->string);
  4914         }
  4915     }
  4916   else
  4917     {
  4918       struct text_pos pos;
  4919 
  4920       if ((IT_CHARPOS (*it) >= ZV && !before_p)
  4921           || (IT_CHARPOS (*it) <= BEGV && before_p))
  4922         return it->face_id;
  4923 
  4924       limit = IT_CHARPOS (*it) + TEXT_PROP_DISTANCE_LIMIT;
  4925       pos = it->current.pos;
  4926 
  4927       if (!it->bidi_p)
  4928         {
  4929           if (before_p)
  4930             DEC_TEXT_POS (pos, it->multibyte_p);
  4931           else
  4932             {
  4933               if (it->what == IT_COMPOSITION)
  4934                 {
  4935                   /* For composition, we must check the position after
  4936                      the composition.  */
  4937                   pos.charpos += it->cmp_it.nchars;
  4938                   pos.bytepos += it->len;
  4939                 }
  4940               else
  4941                 INC_TEXT_POS (pos, it->multibyte_p);
  4942             }
  4943         }
  4944       else
  4945         {
  4946           if (before_p)
  4947             {
  4948               int current_x;
  4949 
  4950               /* With bidi iteration, the character before the current
  4951                  in the visual order cannot be found by simple
  4952                  iteration, because "reverse" reordering is not
  4953                  supported.  Instead, we need to use the move_it_*
  4954                  family of functions, and move to the previous
  4955                  character starting from the beginning of the visual
  4956                  line.  */
  4957               /* Ignore face changes before the first visible
  4958                  character on this display line.  */
  4959               if (it->current_x <= it->first_visible_x)
  4960                 return it->face_id;
  4961               SAVE_IT (it_copy, *it, it_copy_data);
  4962               /* Implementation note: Since move_it_in_display_line
  4963                  works in the iterator geometry, and thinks the first
  4964                  character is always the leftmost, even in R2L lines,
  4965                  we don't need to distinguish between the R2L and L2R
  4966                  cases here.  */
  4967               current_x = it_copy.current_x;
  4968               move_it_vertically_backward (&it_copy, 0);
  4969               move_it_in_display_line (&it_copy, ZV, current_x - 1, MOVE_TO_X);
  4970               pos = it_copy.current.pos;
  4971               RESTORE_IT (it, it, it_copy_data);
  4972             }
  4973           else
  4974             {
  4975               /* Set charpos to the buffer position of the character
  4976                  that comes after IT's current position in the visual
  4977                  order.  */
  4978               int n = (it->what == IT_COMPOSITION ? it->cmp_it.nchars : 1);
  4979 
  4980               it_copy = *it;
  4981               /* If this is the first display element,
  4982                  bidi_move_to_visually_next will deliver character at
  4983                  current position without moving, so we need to enlarge N.  */
  4984               if (it->bidi_it.first_elt)
  4985                 n++;
  4986               while (n--)
  4987                 bidi_move_to_visually_next (&it_copy.bidi_it);
  4988 
  4989               SET_TEXT_POS (pos,
  4990                             it_copy.bidi_it.charpos, it_copy.bidi_it.bytepos);
  4991             }
  4992         }
  4993       eassert (BEGV <= CHARPOS (pos) && CHARPOS (pos) <= ZV);
  4994 
  4995       /* Determine face for CHARSET_ASCII, or unibyte.  */
  4996       face_id = face_at_buffer_position (it->w,
  4997                                          CHARPOS (pos),
  4998                                          &next_check_charpos,
  4999                                          limit, false, -1, 0);
  5000 
  5001       /* Correct the face for charsets different from ASCII.  Do it
  5002          for the multibyte case only.  The face returned above is
  5003          suitable for unibyte text if current_buffer is unibyte.  */
  5004       if (it->multibyte_p)
  5005         {
  5006           int c = FETCH_MULTIBYTE_CHAR (BYTEPOS (pos));
  5007           struct face *face = FACE_FROM_ID (it->f, face_id);
  5008           face_id = FACE_FOR_CHAR (it->f, face, c, CHARPOS (pos), Qnil);
  5009         }
  5010     }
  5011 
  5012   return face_id;
  5013 }
  5014 
  5015 
  5016 
  5017 /***********************************************************************
  5018                             Invisible text
  5019  ***********************************************************************/
  5020 
  5021 /* Set up iterator IT from invisible properties at its current
  5022    position.  Called from handle_stop.  */
  5023 
  5024 static enum prop_handled
  5025 handle_invisible_prop (struct it *it)
  5026 {
  5027   enum prop_handled handled = HANDLED_NORMALLY;
  5028   int invis;
  5029   Lisp_Object prop;
  5030 
  5031   if (STRINGP (it->string))
  5032     {
  5033       Lisp_Object end_charpos, limit;
  5034 
  5035       /* Get the value of the invisible text property at the
  5036          current position.  Value will be nil if there is no such
  5037          property.  */
  5038       end_charpos = make_fixnum (IT_STRING_CHARPOS (*it));
  5039       prop = Fget_text_property (end_charpos, Qinvisible, it->string);
  5040       invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5041 
  5042       if (invis != 0 && IT_STRING_CHARPOS (*it) < it->end_charpos)
  5043         {
  5044           /* Record whether we have to display an ellipsis for the
  5045              invisible text.  */
  5046           bool display_ellipsis_p = (invis == 2);
  5047           ptrdiff_t len, endpos;
  5048 
  5049           handled = HANDLED_RECOMPUTE_PROPS;
  5050 
  5051           /* Get the position at which the next visible text can be
  5052              found in IT->string, if any.  */
  5053           endpos = len = SCHARS (it->string);
  5054           XSETINT (limit, len);
  5055           do
  5056             {
  5057               end_charpos
  5058                 = Fnext_single_property_change (end_charpos, Qinvisible,
  5059                                                 it->string, limit);
  5060               /* Since LIMIT is always an integer, so should be the
  5061                  value returned by Fnext_single_property_change.  */
  5062               eassert (FIXNUMP (end_charpos));
  5063               if (FIXNUMP (end_charpos))
  5064                 {
  5065                   endpos = XFIXNAT (end_charpos);
  5066                   prop = Fget_text_property (end_charpos, Qinvisible, it->string);
  5067                   invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5068                   if (invis == 2)
  5069                     display_ellipsis_p = true;
  5070                 }
  5071               else /* Should never happen; but if it does, exit the loop.  */
  5072                 endpos = len;
  5073             }
  5074           while (invis != 0 && endpos < len);
  5075 
  5076           if (display_ellipsis_p)
  5077             it->ellipsis_p = true;
  5078 
  5079           if (endpos < len)
  5080             {
  5081               /* Text at END_CHARPOS is visible.  Move IT there.  */
  5082               struct text_pos old;
  5083               ptrdiff_t oldpos;
  5084 
  5085               old = it->current.string_pos;
  5086               oldpos = CHARPOS (old);
  5087               if (it->bidi_p)
  5088                 {
  5089                   if (it->bidi_it.first_elt
  5090                       && it->bidi_it.charpos < SCHARS (it->string))
  5091                     bidi_paragraph_init (it->paragraph_embedding,
  5092                                          &it->bidi_it, true);
  5093                   /* Bidi-iterate out of the invisible text.  */
  5094                   do
  5095                     {
  5096                       bidi_move_to_visually_next (&it->bidi_it);
  5097                     }
  5098                   while (oldpos <= it->bidi_it.charpos
  5099                          && it->bidi_it.charpos < endpos
  5100                          && it->bidi_it.charpos < it->bidi_it.string.schars);
  5101 
  5102                   IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  5103                   IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  5104                   if (IT_CHARPOS (*it) >= endpos)
  5105                     it->prev_stop = endpos;
  5106                 }
  5107               else
  5108                 {
  5109                   IT_STRING_CHARPOS (*it) = endpos;
  5110                   compute_string_pos (&it->current.string_pos, old, it->string);
  5111                 }
  5112             }
  5113           else
  5114             {
  5115               /* The rest of the string is invisible.  If this is an
  5116                  overlay string, proceed with the next overlay string
  5117                  or whatever comes and return a character from there.  */
  5118               if (it->current.overlay_string_index >= 0
  5119                   && !display_ellipsis_p)
  5120                 {
  5121                   next_overlay_string (it);
  5122                   /* Don't check for overlay strings when we just
  5123                      finished processing them.  */
  5124                   handled = HANDLED_OVERLAY_STRING_CONSUMED;
  5125                 }
  5126               else
  5127                 {
  5128                   IT_STRING_CHARPOS (*it) = SCHARS (it->string);
  5129                   IT_STRING_BYTEPOS (*it) = SBYTES (it->string);
  5130                 }
  5131             }
  5132         }
  5133     }
  5134   else
  5135     {
  5136       ptrdiff_t newpos, next_stop, start_charpos, tem;
  5137       Lisp_Object pos, overlay;
  5138 
  5139       /* First of all, is there invisible text at this position?  */
  5140       tem = start_charpos = IT_CHARPOS (*it);
  5141       pos = make_fixnum (tem);
  5142       prop = get_char_property_and_overlay (pos, Qinvisible, it->window,
  5143                                             &overlay);
  5144       invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5145 
  5146       /* If we are on invisible text, skip over it.  */
  5147       if (invis != 0 && start_charpos < it->end_charpos)
  5148         {
  5149           /* Record whether we have to display an ellipsis for the
  5150              invisible text.  */
  5151           bool display_ellipsis_p = invis == 2;
  5152 
  5153           handled = HANDLED_RECOMPUTE_PROPS;
  5154 
  5155           /* Loop skipping over invisible text.  The loop is left at
  5156              ZV or with IT on the first char being visible again.  */
  5157           do
  5158             {
  5159               /* Try to skip some invisible text.  Return value is the
  5160                  position reached which can be equal to where we start
  5161                  if there is nothing invisible there.  This skips both
  5162                  over invisible text properties and overlays with
  5163                  invisible property.  */
  5164               newpos = skip_invisible (tem, &next_stop, ZV, it->window);
  5165 
  5166               /* If we skipped nothing at all we weren't at invisible
  5167                  text in the first place.  If everything to the end of
  5168                  the buffer was skipped, end the loop.  */
  5169               if (newpos == tem || newpos >= ZV)
  5170                 invis = 0;
  5171               else
  5172                 {
  5173                   /* We skipped some characters but not necessarily
  5174                      all there are.  Check if we ended up on visible
  5175                      text.  Fget_char_property returns the property of
  5176                      the char before the given position, i.e. if we
  5177                      get invis = 0, this means that the char at
  5178                      newpos is visible.  */
  5179                   pos = make_fixnum (newpos);
  5180                   prop = Fget_char_property (pos, Qinvisible, it->window);
  5181                   invis = TEXT_PROP_MEANS_INVISIBLE (prop);
  5182                 }
  5183 
  5184               /* If we ended up on invisible text, proceed to
  5185                  skip starting with next_stop.  */
  5186               if (invis != 0)
  5187                 tem = next_stop;
  5188 
  5189               /* If there are adjacent invisible texts, don't lose the
  5190                  second one's ellipsis.  */
  5191               if (invis == 2)
  5192                 display_ellipsis_p = true;
  5193             }
  5194           while (invis != 0);
  5195 
  5196           /* The position newpos is now either ZV or on visible text.  */
  5197           if (it->bidi_p)
  5198             {
  5199               ptrdiff_t bpos = CHAR_TO_BYTE (newpos);
  5200               bool on_newline
  5201                 = bpos == ZV_BYTE || FETCH_BYTE (bpos) == '\n';
  5202               bool after_newline
  5203                 = newpos <= BEGV || FETCH_BYTE (bpos - 1) == '\n';
  5204 
  5205               /* If the invisible text ends on a newline or on a
  5206                  character after a newline, we can avoid the costly,
  5207                  character by character, bidi iteration to NEWPOS, and
  5208                  instead simply reseat the iterator there.  That's
  5209                  because all bidi reordering information is tossed at
  5210                  the newline.  This is a big win for modes that hide
  5211                  complete lines, like Outline, Org, etc.  */
  5212               if (on_newline || after_newline)
  5213                 {
  5214                   struct text_pos tpos;
  5215                   bidi_dir_t pdir = it->bidi_it.paragraph_dir;
  5216 
  5217                   SET_TEXT_POS (tpos, newpos, bpos);
  5218                   reseat_1 (it, tpos, false);
  5219                   /* If we reseat on a newline/ZV, we need to prep the
  5220                      bidi iterator for advancing to the next character
  5221                      after the newline/EOB, keeping the current paragraph
  5222                      direction (so that PRODUCE_GLYPHS does TRT wrt
  5223                      prepending/appending glyphs to a glyph row).  */
  5224                   if (on_newline)
  5225                     {
  5226                       it->bidi_it.first_elt = false;
  5227                       it->bidi_it.paragraph_dir = pdir;
  5228                       it->bidi_it.ch = (bpos == ZV_BYTE) ? -1 : '\n';
  5229                       it->bidi_it.nchars = 1;
  5230                       it->bidi_it.ch_len = 1;
  5231                     }
  5232                 }
  5233               else      /* Must use the slow method.  */
  5234                 {
  5235                   /* With bidi iteration, the region of invisible text
  5236                      could start and/or end in the middle of a
  5237                      non-base embedding level.  Therefore, we need to
  5238                      skip invisible text using the bidi iterator,
  5239                      starting at IT's current position, until we find
  5240                      ourselves outside of the invisible text.
  5241                      Skipping invisible text _after_ bidi iteration
  5242                      avoids affecting the visual order of the
  5243                      displayed text when invisible properties are
  5244                      added or removed.  */
  5245                   if (it->bidi_it.first_elt && it->bidi_it.charpos < ZV)
  5246                     {
  5247                       /* If we were `reseat'ed to a new paragraph,
  5248                          determine the paragraph base direction.  We
  5249                          need to do it now because
  5250                          next_element_from_buffer may not have a
  5251                          chance to do it, if we are going to skip any
  5252                          text at the beginning, which resets the
  5253                          FIRST_ELT flag.  */
  5254                       bidi_paragraph_init (it->paragraph_embedding,
  5255                                            &it->bidi_it, true);
  5256                     }
  5257                   do
  5258                     {
  5259                       bidi_move_to_visually_next (&it->bidi_it);
  5260                     }
  5261                   while (it->stop_charpos <= it->bidi_it.charpos
  5262                          && it->bidi_it.charpos < newpos);
  5263                   IT_CHARPOS (*it) = it->bidi_it.charpos;
  5264                   IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  5265                   /* If we overstepped NEWPOS, record its position in
  5266                      the iterator, so that we skip invisible text if
  5267                      later the bidi iteration lands us in the
  5268                      invisible region again. */
  5269                   if (IT_CHARPOS (*it) >= newpos)
  5270                     it->prev_stop = newpos;
  5271                 }
  5272             }
  5273           else
  5274             {
  5275               IT_CHARPOS (*it) = newpos;
  5276               IT_BYTEPOS (*it) = CHAR_TO_BYTE (newpos);
  5277             }
  5278 
  5279           if (display_ellipsis_p)
  5280             {
  5281               /* Make sure that the glyphs of the ellipsis will get
  5282                  correct `charpos' values.  If we would not update
  5283                  it->position here, the glyphs would belong to the
  5284                  last visible character _before_ the invisible
  5285                  text, which confuses `set_cursor_from_row'.
  5286 
  5287                  We use the last invisible position instead of the
  5288                  first because this way the cursor is always drawn on
  5289                  the first "." of the ellipsis, whenever PT is inside
  5290                  the invisible text.  Otherwise the cursor would be
  5291                  placed _after_ the ellipsis when the point is after the
  5292                  first invisible character.  */
  5293               if (!STRINGP (it->object))
  5294                 {
  5295                   it->position.charpos = newpos - 1;
  5296                   it->position.bytepos = CHAR_TO_BYTE (it->position.charpos);
  5297                 }
  5298             }
  5299 
  5300           /* If there are before-strings at the start of invisible
  5301              text, and the text is invisible because of a text
  5302              property, arrange to show before-strings because 20.x did
  5303              it that way.  (If the text is invisible because of an
  5304              overlay property instead of a text property, this is
  5305              already handled in the overlay code.)  */
  5306           if (NILP (overlay)
  5307               && get_overlay_strings (it, it->stop_charpos))
  5308             {
  5309               handled = HANDLED_RECOMPUTE_PROPS;
  5310               if (it->sp > 0)
  5311                 {
  5312                   it->stack[it->sp - 1].display_ellipsis_p = display_ellipsis_p;
  5313                   /* The call to get_overlay_strings above recomputes
  5314                      it->stop_charpos, but it only considers changes
  5315                      in properties and overlays beyond iterator's
  5316                      current position.  This causes us to miss changes
  5317                      that happen exactly where the invisible property
  5318                      ended.  So we play it safe here and force the
  5319                      iterator to check for potential stop positions
  5320                      immediately after the invisible text.  Note that
  5321                      if get_overlay_strings returns true, it
  5322                      normally also pushed the iterator stack, so we
  5323                      need to update the stop position in the slot
  5324                      below the current one.  */
  5325                   it->stack[it->sp - 1].stop_charpos
  5326                     = CHARPOS (it->stack[it->sp - 1].current.pos);
  5327                 }
  5328             }
  5329           else if (display_ellipsis_p)
  5330             {
  5331               it->ellipsis_p = true;
  5332               /* Let the ellipsis display before
  5333                  considering any properties of the following char.
  5334                  Fixes jasonr@gnu.org 01 Oct 07 bug.  */
  5335               handled = HANDLED_RETURN;
  5336             }
  5337         }
  5338     }
  5339 
  5340   return handled;
  5341 }
  5342 
  5343 
  5344 /* Make iterator IT return `...' next.
  5345    Replaces LEN characters from buffer.  */
  5346 
  5347 static void
  5348 setup_for_ellipsis (struct it *it, int len)
  5349 {
  5350   /* Use the display table definition for `...'.  Invalid glyphs
  5351      will be handled by the method returning elements from dpvec.  */
  5352   if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
  5353     {
  5354       struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
  5355       it->dpvec = v->contents;
  5356       it->dpend = v->contents + v->header.size;
  5357     }
  5358   else
  5359     {
  5360       /* Default `...'.  */
  5361       it->dpvec = default_invis_vector;
  5362       it->dpend = default_invis_vector + 3;
  5363     }
  5364 
  5365   it->dpvec_char_len = len;
  5366   it->current.dpvec_index = 0;
  5367   it->dpvec_face_id = -1;
  5368 
  5369   /* Use IT->saved_face_id for the ellipsis, so that it has the same
  5370      face as the preceding text.  IT->saved_face_id was set in
  5371      handle_stop to the face of the preceding character, and will be
  5372      different from IT->face_id only if the invisible text skipped in
  5373      handle_invisible_prop has some non-default face on its first
  5374      character.  We thus ignore the face of the invisible text when we
  5375      display the ellipsis.  IT's face is restored in set_iterator_to_next.  */
  5376   if (it->saved_face_id >= 0)
  5377     it->face_id = it->saved_face_id;
  5378 
  5379   /* If the ellipsis represents buffer text, it means we advanced in
  5380      the buffer, so we should no longer ignore overlay strings.  */
  5381   if (it->method == GET_FROM_BUFFER)
  5382     it->ignore_overlay_strings_at_pos_p = false;
  5383 
  5384   it->method = GET_FROM_DISPLAY_VECTOR;
  5385   it->ellipsis_p = true;
  5386 }
  5387 
  5388 
  5389 static Lisp_Object
  5390 find_display_property (Lisp_Object disp, Lisp_Object prop)
  5391 {
  5392   if (NILP (disp))
  5393     return Qnil;
  5394   /* We have a vector of display specs.  */
  5395   if (VECTORP (disp))
  5396     {
  5397       for (ptrdiff_t i = 0; i < ASIZE (disp); i++)
  5398         {
  5399           Lisp_Object elem = AREF (disp, i);
  5400           if (CONSP (elem)
  5401               && CONSP (XCDR (elem))
  5402               && EQ (XCAR (elem), prop))
  5403             return XCAR (XCDR (elem));
  5404         }
  5405       return Qnil;
  5406     }
  5407   /* We have a list of display specs.  */
  5408   else if (CONSP (disp)
  5409            && CONSP (XCAR (disp)))
  5410     {
  5411       while (!NILP (disp))
  5412         {
  5413           Lisp_Object elem = XCAR (disp);
  5414           if (CONSP (elem)
  5415               && CONSP (XCDR (elem))
  5416               && EQ (XCAR (elem), prop))
  5417             return XCAR (XCDR (elem));
  5418 
  5419           /* Check that we have a proper list before going to the next
  5420              element.  */
  5421           if (CONSP (XCDR (disp)))
  5422             disp = XCDR (disp);
  5423           else
  5424             disp = Qnil;
  5425         }
  5426       return Qnil;
  5427     }
  5428   /* A simple display spec.  */
  5429   else if (CONSP (disp)
  5430            && CONSP (XCDR (disp))
  5431            && EQ (XCAR (disp), prop))
  5432     return XCAR (XCDR (disp));
  5433   else
  5434     return Qnil;
  5435 }
  5436 
  5437 static Lisp_Object
  5438 get_display_property (ptrdiff_t bufpos, Lisp_Object prop, Lisp_Object object)
  5439 {
  5440   return find_display_property (Fget_text_property (make_fixnum (bufpos),
  5441                                                     Qdisplay, object),
  5442                                 prop);
  5443 }
  5444 
  5445 static void
  5446 display_min_width (struct it *it, ptrdiff_t bufpos,
  5447                    Lisp_Object object, Lisp_Object width_spec)
  5448 {
  5449   /* We're being called at the end of the `min-width' sequence,
  5450      probably. */
  5451   if (!NILP (it->min_width_property)
  5452       && !EQ (width_spec, it->min_width_property))
  5453     {
  5454       if (!it->glyph_row)
  5455         return;
  5456 
  5457       /* When called from display_string (i.e., the mode line),
  5458          we're being called with a string as the object, and we
  5459          may be called with many sub-strings belonging to the same
  5460          :propertize run. */
  5461       if ((bufpos == 0
  5462            && !EQ (it->min_width_property,
  5463                    get_display_property (0, Qmin_width, object)))
  5464           /* In a buffer -- check that we're really right after the
  5465              sequence of characters covered by this `min-width'.  */
  5466           || (bufpos > BEGV
  5467               && EQ (it->min_width_property,
  5468                      get_display_property (bufpos - 1, Qmin_width, object))))
  5469         {
  5470           Lisp_Object w = Qnil;
  5471           double width;
  5472 #ifdef HAVE_WINDOW_SYSTEM
  5473           if (FRAME_WINDOW_P (it->f))
  5474             {
  5475               struct font *font = NULL;
  5476               struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5477               font = face->font ? face->font : FRAME_FONT (it->f);
  5478               calc_pixel_width_or_height (&width, it,
  5479                                           XCAR (it->min_width_property),
  5480                                           font, true, NULL);
  5481               width -= it->current_x - it->min_width_start;
  5482               w = list1 (make_int (width));
  5483             }
  5484           else
  5485 #endif
  5486             {
  5487               calc_pixel_width_or_height (&width, it,
  5488                                           XCAR (it->min_width_property),
  5489                                           NULL, true, NULL);
  5490               width -= (it->current_x - it->min_width_start) /
  5491                 FRAME_COLUMN_WIDTH (it->f);
  5492               w = make_int (width);
  5493             }
  5494 
  5495           /* Insert the stretch glyph.  */
  5496           it->object = list3 (Qspace, QCwidth, w);
  5497           produce_stretch_glyph (it);
  5498           if (it->area == TEXT_AREA)
  5499             it->current_x += it->pixel_width;
  5500           it->min_width_property = Qnil;
  5501         }
  5502     }
  5503 
  5504   /* We're at the start of a `min-width' sequence -- record the
  5505      position and the property, so that we can later see if we're at
  5506      the end.  */
  5507   if (CONSP (width_spec))
  5508     {
  5509       if (bufpos == BEGV
  5510           /* Mode line (see above).  */
  5511           || (bufpos == 0
  5512               && !EQ (it->min_width_property,
  5513                       get_display_property (0, Qmin_width, object)))
  5514           /* Buffer.  */
  5515           || (bufpos > BEGV
  5516               && !EQ (width_spec,
  5517                       get_display_property (bufpos - 1, Qmin_width, object))))
  5518         {
  5519           it->min_width_property = width_spec;
  5520           it->min_width_start = it->current_x;
  5521         }
  5522     }
  5523 }
  5524 
  5525 DEFUN ("get-display-property", Fget_display_property,
  5526        Sget_display_property, 2, 4, 0,
  5527        doc: /* Get the value of the `display' property PROP at POSITION.
  5528 If OBJECT, this should be a buffer or string where the property is
  5529 fetched from.  If omitted, OBJECT defaults to the current buffer.
  5530 
  5531 If PROPERTIES, look for value of PROP in PROPERTIES instead of the
  5532 properties at POSITION.  */)
  5533   (Lisp_Object position, Lisp_Object prop, Lisp_Object object,
  5534    Lisp_Object properties)
  5535 {
  5536   if (NILP (properties))
  5537     properties = Fget_text_property (position, Qdisplay, object);
  5538   else
  5539     CHECK_LIST (properties);
  5540 
  5541   return find_display_property (properties, prop);
  5542 }
  5543 
  5544 
  5545 
  5546 /***********************************************************************
  5547                             'display' property
  5548  ***********************************************************************/
  5549 
  5550 /* Set up iterator IT from `display' property at its current position.
  5551    Called from handle_stop.
  5552    We return HANDLED_RETURN if some part of the display property
  5553    overrides the display of the buffer text itself.
  5554    Otherwise we return HANDLED_NORMALLY.  */
  5555 
  5556 static enum prop_handled
  5557 handle_display_prop (struct it *it)
  5558 {
  5559   Lisp_Object propval, object, overlay;
  5560   struct text_pos *position;
  5561   ptrdiff_t bufpos;
  5562   /* Nonzero if some property replaces the display of the text itself.  */
  5563   int display_replaced = 0;
  5564 
  5565   if (STRINGP (it->string))
  5566     {
  5567       object = it->string;
  5568       position = &it->current.string_pos;
  5569       bufpos = CHARPOS (it->current.pos);
  5570     }
  5571   else
  5572     {
  5573       XSETWINDOW (object, it->w);
  5574       position = &it->current.pos;
  5575       bufpos = CHARPOS (*position);
  5576     }
  5577 
  5578   /* Reset those iterator values set from display property values.  */
  5579   it->slice.x = it->slice.y = it->slice.width = it->slice.height = Qnil;
  5580   it->space_width = Qnil;
  5581   it->font_height = Qnil;
  5582   it->voffset = 0;
  5583 
  5584   /* We don't support recursive `display' properties, i.e. string
  5585      values that have a string `display' property, that have a string
  5586      `display' property etc.  */
  5587   if (!it->string_from_display_prop_p)
  5588     it->area = TEXT_AREA;
  5589 
  5590   propval = get_char_property_and_overlay (make_fixnum (position->charpos),
  5591                                            Qdisplay, object, &overlay);
  5592 
  5593   /* Rest of the code must have OBJECT be either a string or a buffer.  */
  5594   if (!STRINGP (it->string))
  5595     object = it->w->contents;
  5596 
  5597   /* Handle min-width ends. */
  5598   if (!NILP (it->min_width_property)
  5599       && NILP (find_display_property (propval, Qmin_width)))
  5600     display_min_width (it, bufpos, object, Qnil);
  5601 
  5602   if (NILP (propval))
  5603     return HANDLED_NORMALLY;
  5604   /* Now OVERLAY is the overlay that gave us this property, or nil
  5605      if it was a text property.  */
  5606 
  5607   display_replaced = handle_display_spec (it, propval, object, overlay,
  5608                                           position, bufpos,
  5609                                           FRAME_WINDOW_P (it->f));
  5610   return display_replaced != 0 ? HANDLED_RETURN : HANDLED_NORMALLY;
  5611 }
  5612 
  5613 /* Subroutine of handle_display_prop.  Returns non-zero if the display
  5614    specification in SPEC is a replacing specification, i.e. it would
  5615    replace the text covered by `display' property with something else,
  5616    such as an image or a display string.  If SPEC includes any kind or
  5617    `(space ...) specification, the value is 2; this is used by
  5618    compute_display_string_pos, which see.
  5619 
  5620    See handle_single_display_spec for documentation of arguments.
  5621    FRAME_WINDOW_P is true if the window being redisplayed is on a
  5622    GUI frame; this argument is used only if IT is NULL, see below.
  5623 
  5624    IT can be NULL, if this is called by the bidi reordering code
  5625    through compute_display_string_pos, which see.  In that case, this
  5626    function only examines SPEC, but does not otherwise "handle" it, in
  5627    the sense that it doesn't set up members of IT from the display
  5628    spec.  */
  5629 static int
  5630 handle_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
  5631                      Lisp_Object overlay, struct text_pos *position,
  5632                      ptrdiff_t bufpos, bool frame_window_p)
  5633 {
  5634   int replacing = 0;
  5635   bool enable_eval = true;
  5636 
  5637   /* Support (disable-eval PROP) which is used by enriched.el.  */
  5638   if (CONSP (spec) && EQ (XCAR (spec), Qdisable_eval))
  5639     {
  5640       enable_eval = false;
  5641       spec = CONSP (XCDR (spec)) ? XCAR (XCDR (spec)) : Qnil;
  5642     }
  5643 
  5644   if (CONSP (spec)
  5645       /* Simple specifications.  */
  5646       && !EQ (XCAR (spec), Qimage)
  5647 #ifdef HAVE_XWIDGETS
  5648       && !EQ (XCAR (spec), Qxwidget)
  5649 #endif
  5650       && !EQ (XCAR (spec), Qspace)
  5651       && !EQ (XCAR (spec), Qwhen)
  5652       && !EQ (XCAR (spec), Qslice)
  5653       && !EQ (XCAR (spec), Qspace_width)
  5654       && !EQ (XCAR (spec), Qheight)
  5655       && !EQ (XCAR (spec), Qraise)
  5656       /* Marginal area specifications.  */
  5657       && !(CONSP (XCAR (spec)) && EQ (XCAR (XCAR (spec)), Qmargin))
  5658       && !EQ (XCAR (spec), Qleft_fringe)
  5659       && !EQ (XCAR (spec), Qright_fringe)
  5660       && !EQ (XCAR (spec), Qmin_width)
  5661       && !NILP (XCAR (spec)))
  5662     {
  5663       for (; CONSP (spec); spec = XCDR (spec))
  5664         {
  5665           int rv = handle_single_display_spec (it, XCAR (spec), object,
  5666                                                overlay, position, bufpos,
  5667                                                replacing, frame_window_p,
  5668                                                enable_eval);
  5669           if (rv != 0)
  5670             {
  5671               replacing = rv;
  5672               /* If some text in a string is replaced, `position' no
  5673                  longer points to the position of `object'.  */
  5674               if (!it || STRINGP (object))
  5675                 break;
  5676             }
  5677         }
  5678     }
  5679   else if (VECTORP (spec))
  5680     {
  5681       ptrdiff_t i;
  5682       for (i = 0; i < ASIZE (spec); ++i)
  5683         {
  5684           int rv = handle_single_display_spec (it, AREF (spec, i), object,
  5685                                                overlay, position, bufpos,
  5686                                                replacing, frame_window_p,
  5687                                                enable_eval);
  5688           if (rv != 0)
  5689             {
  5690               replacing = rv;
  5691               /* If some text in a string is replaced, `position' no
  5692                  longer points to the position of `object'.  */
  5693               if (!it || STRINGP (object))
  5694                 break;
  5695             }
  5696         }
  5697     }
  5698   else
  5699     replacing = handle_single_display_spec (it, spec, object, overlay, position,
  5700                                             bufpos, 0, frame_window_p,
  5701                                             enable_eval);
  5702   return replacing;
  5703 }
  5704 
  5705 /* Value is the position of the end of the `display' property starting
  5706    at START_POS in OBJECT.  */
  5707 
  5708 static struct text_pos
  5709 display_prop_end (struct it *it, Lisp_Object object, struct text_pos start_pos)
  5710 {
  5711   Lisp_Object end;
  5712   struct text_pos end_pos;
  5713 
  5714   end = Fnext_single_char_property_change (make_fixnum (CHARPOS (start_pos)),
  5715                                            Qdisplay, object, Qnil);
  5716   CHARPOS (end_pos) = XFIXNAT (end);
  5717   if (STRINGP (object))
  5718     compute_string_pos (&end_pos, start_pos, it->string);
  5719   else
  5720     BYTEPOS (end_pos) = CHAR_TO_BYTE (XFIXNAT (end));
  5721 
  5722   return end_pos;
  5723 }
  5724 
  5725 
  5726 /* Set up IT from a single `display' property specification SPEC.  OBJECT
  5727    is the object in which the `display' property was found.  *POSITION
  5728    is the position in OBJECT at which the `display' property was found.
  5729    BUFPOS is the buffer position of OBJECT (different from POSITION if
  5730    OBJECT is not a buffer).  DISPLAY_REPLACED non-zero means that we
  5731    previously saw a display specification which already replaced text
  5732    display with something else, for example an image; we ignore such
  5733    properties after the first one has been processed.
  5734 
  5735    OVERLAY is the overlay this `display' property came from,
  5736    or nil if it was a text property.
  5737 
  5738    If SPEC is a `space' or `image' specification, and in some other
  5739    cases too, set *POSITION to the position where the `display'
  5740    property ends.
  5741 
  5742    If IT is NULL, only examine the property specification in SPEC, but
  5743    don't set up IT.  In that case, FRAME_WINDOW_P means SPEC
  5744    is intended to be displayed in a window on a GUI frame.
  5745 
  5746    Enable evaluation of Lisp forms only if ENABLE_EVAL_P is true.
  5747 
  5748    Value is non-zero if something was found which replaces the display
  5749    of buffer or string text.  */
  5750 
  5751 static int
  5752 handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
  5753                             Lisp_Object overlay, struct text_pos *position,
  5754                             ptrdiff_t bufpos, int display_replaced,
  5755                             bool frame_window_p, bool enable_eval_p)
  5756 {
  5757   Lisp_Object form;
  5758   Lisp_Object location, value;
  5759   struct text_pos start_pos = *position;
  5760   void *itdata = NULL;
  5761 
  5762   /* If SPEC is a list of the form `(when FORM . VALUE)', evaluate FORM.
  5763      If the result is non-nil, use VALUE instead of SPEC.  */
  5764   form = Qt;
  5765   if (CONSP (spec) && EQ (XCAR (spec), Qwhen))
  5766     {
  5767       spec = XCDR (spec);
  5768       if (!CONSP (spec))
  5769         return 0;
  5770       form = XCAR (spec);
  5771       spec = XCDR (spec);
  5772     }
  5773 
  5774   if (!NILP (form) && !EQ (form, Qt) && !enable_eval_p)
  5775     form = Qnil;
  5776   if (!NILP (form) && !EQ (form, Qt))
  5777     {
  5778       specpdl_ref count = SPECPDL_INDEX ();
  5779 
  5780       /* Bind `object' to the object having the `display' property, a
  5781          buffer or string.  Bind `position' to the position in the
  5782          object where the property was found, and `buffer-position'
  5783          to the current position in the buffer.  */
  5784 
  5785       if (NILP (object))
  5786         XSETBUFFER (object, current_buffer);
  5787       specbind (Qobject, object);
  5788       specbind (Qposition, make_fixnum (CHARPOS (*position)));
  5789       specbind (Qbuffer_position, make_fixnum (bufpos));
  5790       /* Save and restore the bidi cache, since FORM could be crazy
  5791          enough to re-enter redisplay, e.g., by calling 'message'.  */
  5792       itdata = bidi_shelve_cache ();
  5793       form = safe_eval (form);
  5794       bidi_unshelve_cache (itdata, false);
  5795       form = unbind_to (count, form);
  5796     }
  5797 
  5798   if (NILP (form))
  5799     return 0;
  5800 
  5801   /* Handle `(height HEIGHT)' specifications.  */
  5802   if (CONSP (spec)
  5803       && EQ (XCAR (spec), Qheight)
  5804       && CONSP (XCDR (spec)))
  5805     {
  5806       if (it)
  5807         {
  5808           if (!FRAME_WINDOW_P (it->f))
  5809             return 0;
  5810 
  5811           it->font_height = XCAR (XCDR (spec));
  5812           if (!NILP (it->font_height))
  5813             {
  5814               int new_height = -1;
  5815 
  5816               if (CONSP (it->font_height)
  5817                   && (EQ (XCAR (it->font_height), Qplus)
  5818                       || EQ (XCAR (it->font_height), Qminus))
  5819                   && CONSP (XCDR (it->font_height))
  5820                   && RANGED_FIXNUMP (0, XCAR (XCDR (it->font_height)), INT_MAX))
  5821                 {
  5822                   /* `(+ N)' or `(- N)' where N is an integer.  */
  5823                   int steps = XFIXNUM (XCAR (XCDR (it->font_height)));
  5824                   if (EQ (XCAR (it->font_height), Qplus))
  5825                     steps = - steps;
  5826                   it->face_id = smaller_face (it->f, it->face_id, steps);
  5827                 }
  5828               else if (FUNCTIONP (it->font_height) && enable_eval_p)
  5829                 {
  5830                   /* Call function with current height as argument.
  5831                      Value is the new height.  */
  5832                   struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5833                   Lisp_Object height;
  5834                   itdata = bidi_shelve_cache ();
  5835                   height = safe_call1 (it->font_height,
  5836                                        face->lface[LFACE_HEIGHT_INDEX]);
  5837                   bidi_unshelve_cache (itdata, false);
  5838                   if (NUMBERP (height))
  5839                     new_height = XFLOATINT (height);
  5840                 }
  5841               else if (NUMBERP (it->font_height))
  5842                 {
  5843                   /* Value is a multiple of the canonical char height.  */
  5844                   struct face *f;
  5845 
  5846                   f = FACE_FROM_ID (it->f,
  5847                                     lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID));
  5848                   new_height = (XFLOATINT (it->font_height)
  5849                                 * XFIXNUM (f->lface[LFACE_HEIGHT_INDEX]));
  5850                 }
  5851               else if (enable_eval_p)
  5852                 {
  5853                   /* Evaluate IT->font_height with `height' bound to the
  5854                      current specified height to get the new height.  */
  5855                   specpdl_ref count = SPECPDL_INDEX ();
  5856                   struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5857 
  5858                   specbind (Qheight, face->lface[LFACE_HEIGHT_INDEX]);
  5859                   itdata = bidi_shelve_cache ();
  5860                   value = safe_eval (it->font_height);
  5861                   bidi_unshelve_cache (itdata, false);
  5862                   value = unbind_to (count, value);
  5863 
  5864                   if (NUMBERP (value))
  5865                     new_height = XFLOATINT (value);
  5866                 }
  5867 
  5868               if (new_height > 0)
  5869                 it->face_id = face_with_height (it->f, it->face_id, new_height);
  5870             }
  5871         }
  5872 
  5873       return 0;
  5874     }
  5875 
  5876   /* Handle `(space-width WIDTH)'.  */
  5877   if (CONSP (spec)
  5878       && EQ (XCAR (spec), Qspace_width)
  5879       && CONSP (XCDR (spec)))
  5880     {
  5881       if (it)
  5882         {
  5883           if (!FRAME_WINDOW_P (it->f))
  5884             return 0;
  5885 
  5886           value = XCAR (XCDR (spec));
  5887           if (NUMBERP (value) && XFLOATINT (value) > 0)
  5888             it->space_width = value;
  5889         }
  5890 
  5891       return 0;
  5892     }
  5893 
  5894   /* Handle `(min-width (WIDTH))'.  */
  5895   if (CONSP (spec)
  5896       && EQ (XCAR (spec), Qmin_width)
  5897       && CONSP (XCDR (spec))
  5898       && CONSP (XCAR (XCDR (spec))))
  5899     {
  5900       if (it)
  5901         display_min_width (it, bufpos, object, XCAR (XCDR (spec)));
  5902       return 0;
  5903     }
  5904 
  5905   /* Handle `(slice X Y WIDTH HEIGHT)'.  */
  5906   if (CONSP (spec)
  5907       && EQ (XCAR (spec), Qslice))
  5908     {
  5909       Lisp_Object tem;
  5910 
  5911       if (it)
  5912         {
  5913           if (!FRAME_WINDOW_P (it->f))
  5914             return 0;
  5915 
  5916           if (tem = XCDR (spec), CONSP (tem))
  5917             {
  5918               it->slice.x = XCAR (tem);
  5919               if (tem = XCDR (tem), CONSP (tem))
  5920                 {
  5921                   it->slice.y = XCAR (tem);
  5922                   if (tem = XCDR (tem), CONSP (tem))
  5923                     {
  5924                       it->slice.width = XCAR (tem);
  5925                       if (tem = XCDR (tem), CONSP (tem))
  5926                         it->slice.height = XCAR (tem);
  5927                     }
  5928                 }
  5929             }
  5930         }
  5931 
  5932       return 0;
  5933     }
  5934 
  5935   /* Handle `(raise FACTOR)'.  */
  5936   if (CONSP (spec)
  5937       && EQ (XCAR (spec), Qraise)
  5938       && CONSP (XCDR (spec)))
  5939     {
  5940       if (it)
  5941         {
  5942           if (!FRAME_WINDOW_P (it->f))
  5943             return 0;
  5944 
  5945 #ifdef HAVE_WINDOW_SYSTEM
  5946           value = XCAR (XCDR (spec));
  5947           if (NUMBERP (value))
  5948             {
  5949               struct face *face = FACE_FROM_ID (it->f, it->face_id);
  5950               it->voffset = - (XFLOATINT (value)
  5951                                * (normal_char_height (face->font, -1)));
  5952             }
  5953 #endif /* HAVE_WINDOW_SYSTEM */
  5954         }
  5955 
  5956       return 0;
  5957     }
  5958 
  5959   /* Don't handle the other kinds of display specifications
  5960      inside a string that we got from a `display' property.  */
  5961   if (it && it->string_from_display_prop_p)
  5962     return 0;
  5963 
  5964   /* Characters having this form of property are not displayed, so
  5965      we have to find the end of the property.  */
  5966   if (it)
  5967     {
  5968       start_pos = *position;
  5969       *position = display_prop_end (it, object, start_pos);
  5970       /* If the display property comes from an overlay, don't consider
  5971          any potential stop_charpos values before the end of that
  5972          overlay.  Since display_prop_end will happily find another
  5973          'display' property coming from some other overlay or text
  5974          property on buffer positions before this overlay's end, we
  5975          need to ignore them, or else we risk displaying this
  5976          overlay's display string/image twice.  */
  5977       if (!NILP (overlay))
  5978         {
  5979           ptrdiff_t ovendpos = OVERLAY_END (overlay);
  5980 
  5981           /* Some borderline-sane Lisp might call us with the current
  5982              buffer narrowed so that overlay-end is outside the
  5983              POINT_MIN..POINT_MAX region, which will then cause
  5984              various assertion violations and crashes down the road,
  5985              starting with pop_it when it will attempt to use POSITION
  5986              set below.  Prevent that.  */
  5987           ovendpos = clip_to_bounds (BEGV, ovendpos, ZV);
  5988 
  5989           if (ovendpos > CHARPOS (*position))
  5990             SET_TEXT_POS (*position, ovendpos, CHAR_TO_BYTE (ovendpos));
  5991         }
  5992     }
  5993   value = Qnil;
  5994 
  5995   /* Stop the scan at that end position--we assume that all
  5996      text properties change there.  */
  5997   if (it)
  5998     it->stop_charpos = position->charpos;
  5999 
  6000   /* Handle `(left-fringe BITMAP [FACE])'
  6001      and `(right-fringe BITMAP [FACE])'.  */
  6002   if (CONSP (spec)
  6003       && (EQ (XCAR (spec), Qleft_fringe)
  6004           || EQ (XCAR (spec), Qright_fringe))
  6005       && CONSP (XCDR (spec)))
  6006     {
  6007       if (it)
  6008         {
  6009           if (!FRAME_WINDOW_P (it->f))
  6010             /* If we return here, POSITION has been advanced
  6011                across the text with this property.  */
  6012             {
  6013               /* Synchronize the bidi iterator with POSITION.  This is
  6014                  needed because we are not going to push the iterator
  6015                  on behalf of this display property, so there will be
  6016                  no pop_it call to do this synchronization for us.  */
  6017               if (it->bidi_p)
  6018                 {
  6019                   it->position = *position;
  6020                   iterate_out_of_display_property (it);
  6021                   *position = it->position;
  6022                 }
  6023               return 1;
  6024             }
  6025         }
  6026       else if (!frame_window_p)
  6027         return 1;
  6028 
  6029 #ifdef HAVE_WINDOW_SYSTEM
  6030       value = XCAR (XCDR (spec));
  6031       int fringe_bitmap = SYMBOLP (value) ? lookup_fringe_bitmap (value) : 0;
  6032       if (! fringe_bitmap)
  6033         /* If we return here, POSITION has been advanced
  6034            across the text with this property.  */
  6035         {
  6036           if (it && it->bidi_p)
  6037             {
  6038               it->position = *position;
  6039               iterate_out_of_display_property (it);
  6040               *position = it->position;
  6041             }
  6042           return 1;
  6043         }
  6044 
  6045       if (it)
  6046         {
  6047           int face_id = lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID);
  6048 
  6049           if (CONSP (XCDR (XCDR (spec))))
  6050             {
  6051               Lisp_Object face_name = XCAR (XCDR (XCDR (spec)));
  6052               int face_id2;
  6053               /* Don't allow quitting from lookup_derived_face, for when
  6054                  we are displaying a non-selected window, and the buffer's
  6055                  point was temporarily moved to the window-point.  */
  6056               specpdl_ref count1 = SPECPDL_INDEX ();
  6057               specbind (Qinhibit_quit, Qt);
  6058               face_id2 = lookup_derived_face (it->w, it->f, face_name,
  6059                                               FRINGE_FACE_ID, false);
  6060               unbind_to (count1, Qnil);
  6061               if (face_id2 >= 0)
  6062                 face_id = face_id2;
  6063             }
  6064 
  6065           /* Save current settings of IT so that we can restore them
  6066              when we are finished with the glyph property value.  */
  6067           push_it (it, position);
  6068 
  6069           it->area = TEXT_AREA;
  6070           it->what = IT_IMAGE;
  6071           it->image_id = -1; /* no image */
  6072           it->position = start_pos;
  6073           it->object = NILP (object) ? it->w->contents : object;
  6074           it->method = GET_FROM_IMAGE;
  6075           it->from_overlay = Qnil;
  6076           it->face_id = face_id;
  6077           it->from_disp_prop_p = true;
  6078 
  6079           /* Say that we haven't consumed the characters with
  6080              `display' property yet.  The call to pop_it in
  6081              set_iterator_to_next will clean this up.  */
  6082           *position = start_pos;
  6083 
  6084           if (EQ (XCAR (spec), Qleft_fringe))
  6085             {
  6086               it->left_user_fringe_bitmap = fringe_bitmap;
  6087               it->left_user_fringe_face_id = face_id;
  6088             }
  6089           else
  6090             {
  6091               it->right_user_fringe_bitmap = fringe_bitmap;
  6092               it->right_user_fringe_face_id = face_id;
  6093             }
  6094         }
  6095 #endif /* HAVE_WINDOW_SYSTEM */
  6096       return 1;
  6097     }
  6098 
  6099   /* Prepare to handle `((margin left-margin) ...)',
  6100      `((margin right-margin) ...)' and `((margin nil) ...)'
  6101      prefixes for display specifications.  */
  6102   location = Qunbound;
  6103   if (CONSP (spec) && CONSP (XCAR (spec)))
  6104     {
  6105       Lisp_Object tem;
  6106 
  6107       value = XCDR (spec);
  6108       if (CONSP (value))
  6109         value = XCAR (value);
  6110 
  6111       tem = XCAR (spec);
  6112       if (EQ (XCAR (tem), Qmargin)
  6113           && (tem = XCDR (tem),
  6114               tem = CONSP (tem) ? XCAR (tem) : Qnil,
  6115               (NILP (tem)
  6116                || EQ (tem, Qleft_margin)
  6117                || EQ (tem, Qright_margin))))
  6118         location = tem;
  6119     }
  6120 
  6121   if (BASE_EQ (location, Qunbound))
  6122     {
  6123       location = Qnil;
  6124       value = spec;
  6125     }
  6126 
  6127   /* After this point, VALUE is the property after any
  6128      margin prefix has been stripped.  It must be a string,
  6129      an image specification, or `(space ...)'.
  6130 
  6131      LOCATION specifies where to display: `left-margin',
  6132      `right-margin' or nil.  */
  6133 
  6134   bool valid_p = (STRINGP (value)
  6135 #ifdef HAVE_WINDOW_SYSTEM
  6136                   || ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
  6137                       && valid_image_p (value))
  6138 #endif /* not HAVE_WINDOW_SYSTEM */
  6139              || (CONSP (value) && EQ (XCAR (value), Qspace))
  6140              || ((it ? FRAME_WINDOW_P (it->f) : frame_window_p)
  6141                  && valid_xwidget_spec_p (value)));
  6142 
  6143   if (valid_p && display_replaced == 0)
  6144     {
  6145       int retval = 1;
  6146 
  6147       if (!it)
  6148         {
  6149           /* Callers need to know whether the display spec is any kind
  6150              of `(space ...)' spec that is about to affect text-area
  6151              display.  */
  6152           if (CONSP (value) && EQ (XCAR (value), Qspace) && NILP (location))
  6153             retval = 2;
  6154           return retval;
  6155         }
  6156 
  6157       /* Save current settings of IT so that we can restore them
  6158          when we are finished with the glyph property value.  */
  6159       push_it (it, position);
  6160       it->from_overlay = overlay;
  6161       it->from_disp_prop_p = true;
  6162 
  6163       if (NILP (location))
  6164         it->area = TEXT_AREA;
  6165       else if (EQ (location, Qleft_margin))
  6166         it->area = LEFT_MARGIN_AREA;
  6167       else
  6168         it->area = RIGHT_MARGIN_AREA;
  6169 
  6170       if (STRINGP (value))
  6171         {
  6172           it->string = value;
  6173           it->multibyte_p = STRING_MULTIBYTE (it->string);
  6174           it->current.overlay_string_index = -1;
  6175           IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
  6176           it->end_charpos = it->string_nchars = SCHARS (it->string);
  6177           it->method = GET_FROM_STRING;
  6178           it->stop_charpos = 0;
  6179           it->prev_stop = 0;
  6180           it->base_level_stop = 0;
  6181           it->string_from_display_prop_p = true;
  6182           it->cmp_it.id = -1;
  6183           /* Say that we haven't consumed the characters with
  6184              `display' property yet.  The call to pop_it in
  6185              set_iterator_to_next will clean this up.  */
  6186           if (BUFFERP (object))
  6187             *position = start_pos;
  6188 
  6189           /* Force paragraph direction to be that of the parent
  6190              object.  If the parent object's paragraph direction is
  6191              not yet determined, default to L2R.  */
  6192           if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  6193             it->paragraph_embedding = it->bidi_it.paragraph_dir;
  6194           else
  6195             it->paragraph_embedding = L2R;
  6196 
  6197           /* Set up the bidi iterator for this display string.  */
  6198           if (it->bidi_p)
  6199             {
  6200               it->bidi_it.string.lstring = it->string;
  6201               it->bidi_it.string.s = NULL;
  6202               it->bidi_it.string.schars = it->end_charpos;
  6203               it->bidi_it.string.bufpos = bufpos;
  6204               it->bidi_it.string.from_disp_str = true;
  6205               it->bidi_it.string.unibyte = !it->multibyte_p;
  6206               it->bidi_it.w = it->w;
  6207               bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
  6208             }
  6209         }
  6210       else if (CONSP (value) && EQ (XCAR (value), Qspace))
  6211         {
  6212           it->method = GET_FROM_STRETCH;
  6213           it->object = value;
  6214           *position = it->position = start_pos;
  6215           retval = 1 + (it->area == TEXT_AREA);
  6216         }
  6217       else if (valid_xwidget_spec_p (value))
  6218         {
  6219           it->what = IT_XWIDGET;
  6220           it->method = GET_FROM_XWIDGET;
  6221           it->position = start_pos;
  6222           it->object = NILP (object) ? it->w->contents : object;
  6223           *position = start_pos;
  6224           it->xwidget = lookup_xwidget (value);
  6225         }
  6226 #ifdef HAVE_WINDOW_SYSTEM
  6227       else
  6228         {
  6229           specpdl_ref count = SPECPDL_INDEX ();
  6230 
  6231           it->what = IT_IMAGE;
  6232           /* Don't allow quitting from lookup_image, for when we are
  6233              displaying a non-selected window, and the buffer's point
  6234              was temporarily moved to the window-point.  */
  6235           specbind (Qinhibit_quit, Qt);
  6236           it->image_id = lookup_image (it->f, value, it->face_id);
  6237           unbind_to (count, Qnil);
  6238           it->position = start_pos;
  6239           it->object = NILP (object) ? it->w->contents : object;
  6240           it->method = GET_FROM_IMAGE;
  6241 
  6242           /* Say that we haven't consumed the characters with
  6243              `display' property yet.  The call to pop_it in
  6244              set_iterator_to_next will clean this up.  */
  6245           *position = start_pos;
  6246         }
  6247 #endif /* HAVE_WINDOW_SYSTEM */
  6248 
  6249       return retval;
  6250     }
  6251 
  6252   /* Invalid property or property not supported.  Restore
  6253      POSITION to what it was before.  */
  6254   *position = start_pos;
  6255   return 0;
  6256 }
  6257 
  6258 /* Check if PROP is a display property value whose text should be
  6259    treated as intangible.  OVERLAY is the overlay from which PROP
  6260    came, or nil if it came from a text property.  CHARPOS and BYTEPOS
  6261    specify the buffer position covered by PROP.  */
  6262 
  6263 bool
  6264 display_prop_intangible_p (Lisp_Object prop, Lisp_Object overlay,
  6265                            ptrdiff_t charpos, ptrdiff_t bytepos)
  6266 {
  6267   bool frame_window_p = FRAME_WINDOW_P (XFRAME (selected_frame));
  6268   struct text_pos position;
  6269 
  6270   SET_TEXT_POS (position, charpos, bytepos);
  6271   return (handle_display_spec (NULL, prop, Qnil, overlay,
  6272                                &position, charpos, frame_window_p)
  6273           != 0);
  6274 }
  6275 
  6276 
  6277 /* Return true if PROP is a display sub-property value containing STRING.
  6278 
  6279    Implementation note: this and the following function are really
  6280    special cases of handle_display_spec and
  6281    handle_single_display_spec, and should ideally use the same code.
  6282    Until they do, these two pairs must be consistent and must be
  6283    modified in sync.  */
  6284 
  6285 static bool
  6286 single_display_spec_string_p (Lisp_Object prop, Lisp_Object string)
  6287 {
  6288   if (EQ (string, prop))
  6289     return true;
  6290 
  6291   /* Skip over `when FORM'.  */
  6292   if (CONSP (prop) && EQ (XCAR (prop), Qwhen))
  6293     {
  6294       prop = XCDR (prop);
  6295       if (!CONSP (prop))
  6296         return false;
  6297       /* Actually, the condition following `when' should be eval'ed,
  6298          like handle_single_display_spec does, and we should return
  6299          false if it evaluates to nil.  However, this function is
  6300          called only when the buffer was already displayed and some
  6301          glyph in the glyph matrix was found to come from a display
  6302          string.  Therefore, the condition was already evaluated, and
  6303          the result was non-nil, otherwise the display string wouldn't
  6304          have been displayed and we would have never been called for
  6305          this property.  Thus, we can skip the evaluation and assume
  6306          its result is non-nil.  */
  6307       prop = XCDR (prop);
  6308     }
  6309 
  6310   if (CONSP (prop))
  6311     /* Skip over `margin LOCATION'.  */
  6312     if (EQ (XCAR (prop), Qmargin))
  6313       {
  6314         prop = XCDR (prop);
  6315         if (!CONSP (prop))
  6316           return false;
  6317 
  6318         prop = XCDR (prop);
  6319         if (!CONSP (prop))
  6320           return false;
  6321       }
  6322 
  6323   return EQ (prop, string) || (CONSP (prop) && EQ (XCAR (prop), string));
  6324 }
  6325 
  6326 
  6327 /* Return true if STRING appears in the `display' property PROP.  */
  6328 
  6329 static bool
  6330 display_prop_string_p (Lisp_Object prop, Lisp_Object string)
  6331 {
  6332   if (CONSP (prop)
  6333       && !EQ (XCAR (prop), Qwhen)
  6334       && !(CONSP (XCAR (prop)) && EQ (Qmargin, XCAR (XCAR (prop)))))
  6335     {
  6336       /* A list of sub-properties.  */
  6337       while (CONSP (prop))
  6338         {
  6339           if (single_display_spec_string_p (XCAR (prop), string))
  6340             return true;
  6341           prop = XCDR (prop);
  6342         }
  6343     }
  6344   else if (VECTORP (prop))
  6345     {
  6346       /* A vector of sub-properties.  */
  6347       ptrdiff_t i;
  6348       for (i = 0; i < ASIZE (prop); ++i)
  6349         if (single_display_spec_string_p (AREF (prop, i), string))
  6350           return true;
  6351     }
  6352   else
  6353     return single_display_spec_string_p (prop, string);
  6354 
  6355   return false;
  6356 }
  6357 
  6358 /* Look for STRING in overlays and text properties in the current
  6359    buffer, between character positions FROM and TO (excluding TO).
  6360    BACK_P means look back (in this case, TO is supposed to be
  6361    less than FROM).
  6362    Value is the first character position where STRING was found, or
  6363    zero if it wasn't found before hitting TO.
  6364 
  6365    This function may only use code that doesn't eval because it is
  6366    called asynchronously from note_mouse_highlight.  */
  6367 
  6368 static ptrdiff_t
  6369 string_buffer_position_lim (Lisp_Object string,
  6370                             ptrdiff_t from, ptrdiff_t to, bool back_p)
  6371 {
  6372   Lisp_Object limit, prop, pos;
  6373   bool found = false;
  6374 
  6375   pos = make_fixnum (max (from, BEGV));
  6376 
  6377   if (!back_p)  /* looking forward */
  6378     {
  6379       limit = make_fixnum (min (to, ZV));
  6380       while (!found && !EQ (pos, limit))
  6381         {
  6382           prop = Fget_char_property (pos, Qdisplay, Qnil);
  6383           if (!NILP (prop) && display_prop_string_p (prop, string))
  6384             found = true;
  6385           else
  6386             pos = Fnext_single_char_property_change (pos, Qdisplay, Qnil,
  6387                                                      limit);
  6388         }
  6389     }
  6390   else          /* looking back */
  6391     {
  6392       limit = make_fixnum (max (to, BEGV));
  6393       while (!found && !EQ (pos, limit))
  6394         {
  6395           prop = Fget_char_property (pos, Qdisplay, Qnil);
  6396           if (!NILP (prop) && display_prop_string_p (prop, string))
  6397             found = true;
  6398           else
  6399             pos = Fprevious_single_char_property_change (pos, Qdisplay, Qnil,
  6400                                                          limit);
  6401         }
  6402     }
  6403 
  6404   return found ? XFIXNUM (pos) : 0;
  6405 }
  6406 
  6407 /* Determine which buffer position in current buffer STRING comes from.
  6408    AROUND_CHARPOS is an approximate position where it could come from.
  6409    Value is the buffer position or 0 if it couldn't be determined.
  6410 
  6411    This function is necessary because we don't record buffer positions
  6412    in glyphs generated from strings (to keep struct glyph small).
  6413    This function may only use code that doesn't eval because it is
  6414    called asynchronously from note_mouse_highlight.  */
  6415 
  6416 static ptrdiff_t
  6417 string_buffer_position (Lisp_Object string, ptrdiff_t around_charpos)
  6418 {
  6419   const int MAX_DISTANCE = 1000;
  6420   ptrdiff_t forward_limit = min (around_charpos + MAX_DISTANCE, ZV);
  6421   ptrdiff_t found = string_buffer_position_lim (string, around_charpos,
  6422                                                 forward_limit, false);
  6423 
  6424   if (!found)
  6425     {
  6426       ptrdiff_t backward_limit = max (around_charpos - MAX_DISTANCE, BEGV);
  6427       found = string_buffer_position_lim (string, around_charpos,
  6428                                           backward_limit, true);
  6429     }
  6430   return found;
  6431 }
  6432 
  6433 
  6434 
  6435 /***********************************************************************
  6436                         `composition' property
  6437  ***********************************************************************/
  6438 
  6439 /* Set up iterator IT from `composition' property at its current
  6440    position.  Called from handle_stop.  */
  6441 
  6442 static enum prop_handled
  6443 handle_composition_prop (struct it *it)
  6444 {
  6445   Lisp_Object prop, string;
  6446   ptrdiff_t pos, pos_byte, start, end;
  6447 
  6448   if (STRINGP (it->string))
  6449     {
  6450       unsigned char *s;
  6451 
  6452       pos = IT_STRING_CHARPOS (*it);
  6453       pos_byte = IT_STRING_BYTEPOS (*it);
  6454       string = it->string;
  6455       s = SDATA (string) + pos_byte;
  6456       if (STRING_MULTIBYTE (string))
  6457         it->c = STRING_CHAR (s);
  6458       else
  6459         it->c = *s;
  6460     }
  6461   else
  6462     {
  6463       pos = IT_CHARPOS (*it);
  6464       pos_byte = IT_BYTEPOS (*it);
  6465       string = Qnil;
  6466       it->c = FETCH_CHAR (pos_byte);
  6467     }
  6468 
  6469   /* If there's a valid composition and point is not inside of the
  6470      composition (in the case that the composition is from the current
  6471      buffer), draw a glyph composed from the composition components.  */
  6472   if (find_composition (pos, -1, &start, &end, &prop, string)
  6473       && composition_valid_p (start, end, prop)
  6474       && (STRINGP (it->string) || (PT <= start || PT >= end)))
  6475     {
  6476       if (start < pos)
  6477         /* As we can't handle this situation (perhaps font-lock added
  6478            a new composition), we just return here hoping that next
  6479            redisplay will detect this composition much earlier.  */
  6480         return HANDLED_NORMALLY;
  6481       if (start != pos)
  6482         {
  6483           if (STRINGP (it->string))
  6484             pos_byte = string_char_to_byte (it->string, start);
  6485           else
  6486             pos_byte = CHAR_TO_BYTE (start);
  6487         }
  6488       it->cmp_it.id = get_composition_id (start, pos_byte, end - start,
  6489                                                prop, string);
  6490 
  6491       if (it->cmp_it.id >= 0)
  6492         {
  6493           it->cmp_it.ch = -1;
  6494           it->cmp_it.nchars = COMPOSITION_LENGTH (prop);
  6495           it->cmp_it.nglyphs = -1;
  6496         }
  6497     }
  6498 
  6499   return HANDLED_NORMALLY;
  6500 }
  6501 
  6502 
  6503 
  6504 /***********************************************************************
  6505                            Overlay strings
  6506  ***********************************************************************/
  6507 
  6508 /* The following structure is used to record overlay strings for
  6509    later sorting in load_overlay_strings.  */
  6510 
  6511 struct overlay_entry
  6512 {
  6513   Lisp_Object overlay;
  6514   Lisp_Object string;
  6515   EMACS_INT priority;
  6516   bool after_string_p;
  6517 };
  6518 
  6519 
  6520 /* Set up iterator IT from overlay strings at its current position.
  6521    Called from handle_stop.  */
  6522 
  6523 static enum prop_handled
  6524 handle_overlay_change (struct it *it)
  6525 {
  6526   if (!STRINGP (it->string) && get_overlay_strings (it, 0))
  6527     return HANDLED_RECOMPUTE_PROPS;
  6528   else
  6529     return HANDLED_NORMALLY;
  6530 }
  6531 
  6532 
  6533 /* Set up the next overlay string for delivery by IT, if there is an
  6534    overlay string to deliver.  Called by set_iterator_to_next when the
  6535    end of the current overlay string is reached.  If there are more
  6536    overlay strings to display, IT->string and
  6537    IT->current.overlay_string_index are set appropriately here.
  6538    Otherwise IT->string is set to nil.  */
  6539 
  6540 static void
  6541 next_overlay_string (struct it *it)
  6542 {
  6543   ++it->current.overlay_string_index;
  6544   if (it->current.overlay_string_index == it->n_overlay_strings)
  6545     {
  6546       /* No more overlay strings.  Restore IT's settings to what
  6547          they were before overlay strings were processed, and
  6548          continue to deliver from current_buffer.  */
  6549 
  6550       it->ellipsis_p = it->stack[it->sp - 1].display_ellipsis_p;
  6551       pop_it (it);
  6552       eassert (it->sp > 0
  6553                || (NILP (it->string)
  6554                    && it->method == GET_FROM_BUFFER
  6555                    && it->stop_charpos >= BEGV
  6556                    && it->stop_charpos <= it->end_charpos));
  6557       it->current.overlay_string_index = -1;
  6558       it->n_overlay_strings = 0;
  6559       /* If there's an empty display string on the stack, pop the
  6560          stack, to resync the bidi iterator with IT's position.  Such
  6561          empty strings are pushed onto the stack in
  6562          get_overlay_strings_1.  */
  6563       if (it->sp > 0 && STRINGP (it->string) && !SCHARS (it->string))
  6564         pop_it (it);
  6565 
  6566       /* Since we've exhausted overlay strings at this buffer
  6567          position, set the flag to ignore overlays until we move to
  6568          another position.  (The flag will be reset in
  6569          next_element_from_buffer.)  But don't do that if the overlay
  6570          strings were loaded at position other than the current one,
  6571          which could happen if we called pop_it above, or if the
  6572          overlay strings were loaded by handle_invisible_prop at the
  6573          beginning of invisible text.  */
  6574       if (it->overlay_strings_charpos == IT_CHARPOS (*it))
  6575         it->ignore_overlay_strings_at_pos_p = true;
  6576 
  6577       /* If we're at the end of the buffer, record that we have
  6578          processed the overlay strings there already, so that
  6579          next_element_from_buffer doesn't try it again.  */
  6580       if (NILP (it->string)
  6581           && IT_CHARPOS (*it) >= it->end_charpos
  6582           && it->overlay_strings_charpos >= it->end_charpos)
  6583         it->overlay_strings_at_end_processed_p = true;
  6584       /* Note: we reset overlay_strings_charpos only here, to make
  6585          sure the just-processed overlays were indeed at EOB.
  6586          Otherwise, overlays on text with invisible text property,
  6587          which are processed with IT's position past the invisible
  6588          text, might fool us into thinking the overlays at EOB were
  6589          already processed (linum-mode can cause this, for
  6590          example).  */
  6591       it->overlay_strings_charpos = -1;
  6592     }
  6593   else
  6594     {
  6595       /* There are more overlay strings to process.  If
  6596          IT->current.overlay_string_index has advanced to a position
  6597          where we must load IT->overlay_strings with more strings, do
  6598          it.  We must load at the IT->overlay_strings_charpos where
  6599          IT->n_overlay_strings was originally computed; when invisible
  6600          text is present, this might not be IT_CHARPOS (Bug#7016).  */
  6601       int i = it->current.overlay_string_index % OVERLAY_STRING_CHUNK_SIZE;
  6602 
  6603       if (it->current.overlay_string_index && i == 0)
  6604         load_overlay_strings (it, it->overlay_strings_charpos);
  6605 
  6606       /* Initialize IT to deliver display elements from the overlay
  6607          string.  */
  6608       it->string = it->overlay_strings[i];
  6609       it->multibyte_p = STRING_MULTIBYTE (it->string);
  6610       SET_TEXT_POS (it->current.string_pos, 0, 0);
  6611       it->method = GET_FROM_STRING;
  6612       it->stop_charpos = 0;
  6613       it->end_charpos = SCHARS (it->string);
  6614       if (it->cmp_it.stop_pos >= 0)
  6615         it->cmp_it.stop_pos = 0;
  6616       it->prev_stop = 0;
  6617       it->base_level_stop = 0;
  6618 
  6619       /* Set up the bidi iterator for this overlay string.  */
  6620       if (it->bidi_p)
  6621         {
  6622           it->bidi_it.string.lstring = it->string;
  6623           it->bidi_it.string.s = NULL;
  6624           it->bidi_it.string.schars = SCHARS (it->string);
  6625           it->bidi_it.string.bufpos = it->overlay_strings_charpos;
  6626           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
  6627           it->bidi_it.string.unibyte = !it->multibyte_p;
  6628           it->bidi_it.w = it->w;
  6629           bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
  6630         }
  6631     }
  6632 
  6633   CHECK_IT (it);
  6634 }
  6635 
  6636 
  6637 /* Compare two overlay_entry structures E1 and E2.  Used as a
  6638    comparison function for qsort in load_overlay_strings.  Overlay
  6639    strings for the same position are sorted so that
  6640 
  6641    1. All after-strings come in front of before-strings, except
  6642    when they come from the same overlay.
  6643 
  6644    2. Within after-strings, strings are sorted so that overlay strings
  6645    from overlays with higher priorities come first.
  6646 
  6647    2. Within before-strings, strings are sorted so that overlay
  6648    strings from overlays with higher priorities come last.
  6649 
  6650    Value is analogous to strcmp.  */
  6651 
  6652 
  6653 static int
  6654 compare_overlay_entries (const void *e1, const void *e2)
  6655 {
  6656   struct overlay_entry const *entry1 = e1;
  6657   struct overlay_entry const *entry2 = e2;
  6658   int result;
  6659 
  6660   if (entry1->after_string_p != entry2->after_string_p)
  6661     {
  6662       /* Let after-strings appear in front of before-strings if
  6663          they come from different overlays.  */
  6664       if (EQ (entry1->overlay, entry2->overlay))
  6665         result = entry1->after_string_p ? 1 : -1;
  6666       else
  6667         result = entry1->after_string_p ? -1 : 1;
  6668     }
  6669   else if (entry1->priority != entry2->priority)
  6670     {
  6671       if (entry1->after_string_p)
  6672         /* After-strings sorted in order of decreasing priority.  */
  6673         result = entry2->priority < entry1->priority ? -1 : 1;
  6674       else
  6675         /* Before-strings sorted in order of increasing priority.  */
  6676         result = entry1->priority < entry2->priority ? -1 : 1;
  6677     }
  6678   else
  6679     result = 0;
  6680 
  6681   return result;
  6682 }
  6683 
  6684 
  6685 /* Load the vector IT->overlay_strings with overlay strings from IT's
  6686    current buffer position, or from CHARPOS if that is > 0.  Set
  6687    IT->n_overlays to the total number of overlay strings found.
  6688 
  6689    Overlay strings are processed OVERLAY_STRING_CHUNK_SIZE strings at
  6690    a time.  On entry into load_overlay_strings,
  6691    IT->current.overlay_string_index gives the number of overlay
  6692    strings that have already been loaded by previous calls to this
  6693    function.
  6694 
  6695    IT->add_overlay_start contains an additional overlay start
  6696    position to consider for taking overlay strings from, if non-zero.
  6697    This position comes into play when the overlay has an `invisible'
  6698    property, and both before and after-strings.  When we've skipped to
  6699    the end of the overlay, because of its `invisible' property, we
  6700    nevertheless want its before-string to appear.
  6701    IT->add_overlay_start will contain the overlay start position
  6702    in this case.
  6703 
  6704    Overlay strings are sorted so that after-string strings come in
  6705    front of before-string strings.  Within before and after-strings,
  6706    strings are sorted by overlay priority.  See also function
  6707    compare_overlay_entries.  */
  6708 
  6709 static void
  6710 load_overlay_strings (struct it *it, ptrdiff_t charpos)
  6711 {
  6712   ptrdiff_t n = 0;
  6713   struct overlay_entry entriesbuf[20];
  6714   ptrdiff_t size = ARRAYELTS (entriesbuf);
  6715   struct overlay_entry *entries = entriesbuf;
  6716   struct itree_node *node;
  6717 
  6718   USE_SAFE_ALLOCA;
  6719 
  6720   if (charpos <= 0)
  6721     charpos = IT_CHARPOS (*it);
  6722 
  6723   /* Append the overlay string STRING of overlay OVERLAY to vector
  6724      `entries' which has size `size' and currently contains `n'
  6725      elements.  AFTER_P means STRING is an after-string of
  6726      OVERLAY.  */
  6727 #define RECORD_OVERLAY_STRING(OVERLAY, STRING, AFTER_P)                 \
  6728   do                                                                    \
  6729     {                                                                   \
  6730       Lisp_Object priority;                                             \
  6731                                                                         \
  6732       if (n == size)                                                    \
  6733         {                                                               \
  6734           struct overlay_entry *old = entries;                          \
  6735           SAFE_NALLOCA (entries, 2, size);                              \
  6736           memcpy (entries, old, size * sizeof *entries);                \
  6737           size *= 2;                                                    \
  6738         }                                                               \
  6739                                                                         \
  6740       entries[n].string = (STRING);                                     \
  6741       entries[n].overlay = (OVERLAY);                                   \
  6742       priority = Foverlay_get ((OVERLAY), Qpriority);                   \
  6743       entries[n].priority = FIXNUMP (priority) ? XFIXNUM (priority) : 0;  \
  6744       entries[n].after_string_p = (AFTER_P);                            \
  6745       ++n;                                                              \
  6746     }                                                                   \
  6747   while (false)
  6748 
  6749 
  6750   /* Process overlays.  */
  6751   ITREE_FOREACH (node, current_buffer->overlays, charpos - 1, charpos + 1, DESCENDING)
  6752     {
  6753       Lisp_Object overlay = node->data;
  6754       eassert (OVERLAYP (overlay));
  6755       ptrdiff_t start = node->begin;
  6756       ptrdiff_t end = node->end;
  6757 
  6758       /* Skip this overlay if it doesn't start or end at IT's current
  6759          position.  */
  6760       if (end != charpos && start != charpos)
  6761         continue;
  6762 
  6763       /* Skip this overlay if it doesn't apply to IT->w.  */
  6764       Lisp_Object window = Foverlay_get (overlay, Qwindow);
  6765       if (WINDOWP (window) && XWINDOW (window) != it->w)
  6766         continue;
  6767 
  6768       /* If the text ``under'' the overlay is invisible, both before-
  6769          and after-strings from this overlay are visible; start and
  6770          end position are indistinguishable.  */
  6771       Lisp_Object invisible = Foverlay_get (overlay, Qinvisible);
  6772       int invis = TEXT_PROP_MEANS_INVISIBLE (invisible);
  6773 
  6774       /* If overlay has a non-empty before-string, record it.  */
  6775       Lisp_Object str;
  6776       if ((start == charpos || (end == charpos && invis != 0))
  6777           && (str = Foverlay_get (overlay, Qbefore_string), STRINGP (str))
  6778           && SCHARS (str))
  6779         RECORD_OVERLAY_STRING (overlay, str, false);
  6780 
  6781       /* If overlay has a non-empty after-string, record it.  */
  6782       if ((end == charpos || (start == charpos && invis != 0))
  6783           && (str = Foverlay_get (overlay, Qafter_string), STRINGP (str))
  6784           && SCHARS (str))
  6785         RECORD_OVERLAY_STRING (overlay, str, true);
  6786     }
  6787 
  6788 #undef RECORD_OVERLAY_STRING
  6789 
  6790   /* Sort entries.  */
  6791   if (n > 1)
  6792     qsort (entries, n, sizeof *entries, compare_overlay_entries);
  6793 
  6794   /* Record number of overlay strings, and where we computed it.  */
  6795   it->n_overlay_strings = n;
  6796   it->overlay_strings_charpos = charpos;
  6797 
  6798   /* IT->current.overlay_string_index is the number of overlay strings
  6799      that have already been consumed by IT.  Copy some of the
  6800      remaining overlay strings to IT->overlay_strings.  */
  6801   ptrdiff_t j = it->current.overlay_string_index;
  6802   for (ptrdiff_t i = 0; i < OVERLAY_STRING_CHUNK_SIZE && j < n; i++, j++)
  6803     {
  6804       it->overlay_strings[i] = entries[j].string;
  6805       it->string_overlays[i] = entries[j].overlay;
  6806     }
  6807 
  6808   CHECK_IT (it);
  6809   SAFE_FREE ();
  6810 }
  6811 
  6812 
  6813 /* Get the first chunk of overlay strings at IT's current buffer
  6814    position, or at CHARPOS if that is > 0.  Value is true if at
  6815    least one overlay string was found.  */
  6816 
  6817 static bool
  6818 get_overlay_strings_1 (struct it *it, ptrdiff_t charpos, bool compute_stop_p)
  6819 {
  6820   /* Get the first OVERLAY_STRING_CHUNK_SIZE overlay strings to
  6821      process.  This fills IT->overlay_strings with strings, and sets
  6822      IT->n_overlay_strings to the total number of strings to process.
  6823      IT->pos.overlay_string_index has to be set temporarily to zero
  6824      because load_overlay_strings needs this; it must be set to -1
  6825      when no overlay strings are found because a zero value would
  6826      indicate a position in the first overlay string.  */
  6827   it->current.overlay_string_index = 0;
  6828   load_overlay_strings (it, charpos);
  6829 
  6830   /* If we found overlay strings, set up IT to deliver display
  6831      elements from the first one.  Otherwise set up IT to deliver
  6832      from current_buffer.  */
  6833   if (it->n_overlay_strings)
  6834     {
  6835       /* Make sure we know settings in current_buffer, so that we can
  6836          restore meaningful values when we're done with the overlay
  6837          strings.  */
  6838       if (compute_stop_p)
  6839         compute_stop_pos (it);
  6840       eassert (it->face_id >= 0);
  6841 
  6842       /* Save IT's settings.  They are restored after all overlay
  6843          strings have been processed.  */
  6844       eassert (!compute_stop_p || it->sp == 0);
  6845 
  6846       /* When called from handle_stop, there might be an empty display
  6847          string loaded.  In that case, don't bother saving it.  But
  6848          don't use this optimization with the bidi iterator, since we
  6849          need the corresponding pop_it call to resync the bidi
  6850          iterator's position with IT's position, after we are done
  6851          with the overlay strings.  (The corresponding call to pop_it
  6852          in case of an empty display string is in
  6853          next_overlay_string.)  */
  6854       if (!(!it->bidi_p
  6855             && STRINGP (it->string) && !SCHARS (it->string)))
  6856         push_it (it, NULL);
  6857 
  6858       /* Set up IT to deliver display elements from the first overlay
  6859          string.  */
  6860       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
  6861       it->string = it->overlay_strings[0];
  6862       it->from_overlay = Qnil;
  6863       it->stop_charpos = 0;
  6864       eassert (STRINGP (it->string));
  6865       it->end_charpos = SCHARS (it->string);
  6866       it->prev_stop = 0;
  6867       it->base_level_stop = 0;
  6868       it->multibyte_p = STRING_MULTIBYTE (it->string);
  6869       it->method = GET_FROM_STRING;
  6870       it->from_disp_prop_p = 0;
  6871       it->cmp_it.id = -1;
  6872 
  6873       /* Force paragraph direction to be that of the parent
  6874          buffer.  */
  6875       if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  6876         it->paragraph_embedding = it->bidi_it.paragraph_dir;
  6877       else
  6878         it->paragraph_embedding = L2R;
  6879 
  6880       /* Set up the bidi iterator for this overlay string.  */
  6881       if (it->bidi_p)
  6882         {
  6883           ptrdiff_t pos = (charpos > 0 ? charpos : IT_CHARPOS (*it));
  6884 
  6885           it->bidi_it.string.lstring = it->string;
  6886           it->bidi_it.string.s = NULL;
  6887           it->bidi_it.string.schars = SCHARS (it->string);
  6888           it->bidi_it.string.bufpos = pos;
  6889           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
  6890           it->bidi_it.string.unibyte = !it->multibyte_p;
  6891           it->bidi_it.w = it->w;
  6892           bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
  6893         }
  6894       return true;
  6895     }
  6896 
  6897   it->current.overlay_string_index = -1;
  6898   return false;
  6899 }
  6900 
  6901 static bool
  6902 get_overlay_strings (struct it *it, ptrdiff_t charpos)
  6903 {
  6904   it->string = Qnil;
  6905   it->method = GET_FROM_BUFFER;
  6906 
  6907   get_overlay_strings_1 (it, charpos, true);
  6908 
  6909   CHECK_IT (it);
  6910 
  6911   /* Value is true if we found at least one overlay string.  */
  6912   return STRINGP (it->string);
  6913 }
  6914 
  6915 
  6916 
  6917 /***********************************************************************
  6918                       Saving and restoring state
  6919  ***********************************************************************/
  6920 
  6921 /* Save current settings of IT on IT->stack.  Called, for example,
  6922    before setting up IT for an overlay string, to be able to restore
  6923    IT's settings to what they were after the overlay string has been
  6924    processed.  If POSITION is non-NULL, it is the position to save on
  6925    the stack instead of IT->position.  */
  6926 
  6927 static void
  6928 push_it (struct it *it, struct text_pos *position)
  6929 {
  6930   struct iterator_stack_entry *p;
  6931 
  6932   eassert (it->sp < IT_STACK_SIZE);
  6933   p = it->stack + it->sp;
  6934 
  6935   p->stop_charpos = it->stop_charpos;
  6936   p->prev_stop = it->prev_stop;
  6937   p->base_level_stop = it->base_level_stop;
  6938   p->cmp_it = it->cmp_it;
  6939   eassert (it->face_id >= 0);
  6940   p->face_id = it->face_id;
  6941   p->string = it->string;
  6942   p->method = it->method;
  6943   p->from_overlay = it->from_overlay;
  6944   switch (p->method)
  6945     {
  6946     case GET_FROM_IMAGE:
  6947       p->u.image.object = it->object;
  6948       p->u.image.image_id = it->image_id;
  6949       p->u.image.slice = it->slice;
  6950       break;
  6951     case GET_FROM_STRETCH:
  6952       p->u.stretch.object = it->object;
  6953       break;
  6954     case GET_FROM_XWIDGET:
  6955       p->u.xwidget.object = it->object;
  6956       break;
  6957     case GET_FROM_BUFFER:
  6958     case GET_FROM_DISPLAY_VECTOR:
  6959     case GET_FROM_STRING:
  6960     case GET_FROM_C_STRING:
  6961       break;
  6962     default:
  6963       emacs_abort ();
  6964     }
  6965   p->position = position ? *position : it->position;
  6966   p->current = it->current;
  6967   p->end_charpos = it->end_charpos;
  6968   p->string_nchars = it->string_nchars;
  6969   p->area = it->area;
  6970   p->multibyte_p = it->multibyte_p;
  6971   p->avoid_cursor_p = it->avoid_cursor_p;
  6972   p->space_width = it->space_width;
  6973   p->font_height = it->font_height;
  6974   p->voffset = it->voffset;
  6975   p->string_from_display_prop_p = it->string_from_display_prop_p;
  6976   p->string_from_prefix_prop_p = it->string_from_prefix_prop_p;
  6977   p->display_ellipsis_p = false;
  6978   p->line_wrap = it->line_wrap;
  6979   p->bidi_p = it->bidi_p;
  6980   p->paragraph_embedding = it->paragraph_embedding;
  6981   p->from_disp_prop_p = it->from_disp_prop_p;
  6982   ++it->sp;
  6983 
  6984   /* Save the state of the bidi iterator as well. */
  6985   if (it->bidi_p)
  6986     bidi_push_it (&it->bidi_it);
  6987 }
  6988 
  6989 static void
  6990 iterate_out_of_display_property (struct it *it)
  6991 {
  6992   bool buffer_p = !STRINGP (it->string);
  6993   ptrdiff_t eob = (buffer_p ? ZV : it->end_charpos);
  6994   ptrdiff_t bob = (buffer_p ? BEGV : 0);
  6995 
  6996   eassert (eob >= CHARPOS (it->position) && CHARPOS (it->position) >= bob);
  6997 
  6998   /* Maybe initialize paragraph direction.  If we are at the beginning
  6999      of a new paragraph, next_element_from_buffer may not have a
  7000      chance to do that.  */
  7001   if (it->bidi_it.first_elt && it->bidi_it.charpos < eob)
  7002     bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, true);
  7003   /* prev_stop can be zero, so check against BEGV as well.  */
  7004   while (it->bidi_it.charpos >= bob
  7005          && it->prev_stop <= it->bidi_it.charpos
  7006          && it->bidi_it.charpos < CHARPOS (it->position)
  7007          && it->bidi_it.charpos < eob)
  7008     bidi_move_to_visually_next (&it->bidi_it);
  7009   /* Record the stop_pos we just crossed, for when we cross it
  7010      back, maybe.  */
  7011   if (it->bidi_it.charpos > CHARPOS (it->position))
  7012     it->prev_stop = CHARPOS (it->position);
  7013   /* If we ended up not where pop_it put us, resync IT's
  7014      positional members with the bidi iterator. */
  7015   if (it->bidi_it.charpos != CHARPOS (it->position))
  7016     SET_TEXT_POS (it->position, it->bidi_it.charpos, it->bidi_it.bytepos);
  7017   if (buffer_p)
  7018     it->current.pos = it->position;
  7019   else
  7020     it->current.string_pos = it->position;
  7021 }
  7022 
  7023 /* Restore the IT->face_box_p flag, since it could have been
  7024    overwritten by the face of the object that we just finished
  7025    displaying.  Also, set the IT->start_of_box_run_p flag if the
  7026    change in faces requires that.  */
  7027 static void
  7028 restore_face_box_flags (struct it *it, int prev_face_id)
  7029 {
  7030   struct face *face = FACE_FROM_ID_OR_NULL (it->f, it->face_id);
  7031 
  7032   if (face)
  7033     {
  7034       struct face *prev_face = FACE_FROM_ID_OR_NULL (it->f, prev_face_id);
  7035 
  7036       if (!(it->start_of_box_run_p && prev_face && prev_face->box))
  7037         it->start_of_box_run_p = (face->box != FACE_NO_BOX
  7038                                   && (prev_face == NULL
  7039                                       || prev_face->box == FACE_NO_BOX));
  7040       it->face_box_p = face->box != FACE_NO_BOX;
  7041     }
  7042 }
  7043 
  7044 /* Restore IT's settings from IT->stack.  Called, for example, when no
  7045    more overlay strings must be processed, and we return to delivering
  7046    display elements from a buffer, or when the end of a string from a
  7047    `display' property is reached and we return to delivering display
  7048    elements from an overlay string, or from a buffer.  */
  7049 
  7050 static void
  7051 pop_it (struct it *it)
  7052 {
  7053   struct iterator_stack_entry *p;
  7054   bool from_display_prop = it->from_disp_prop_p;
  7055   ptrdiff_t prev_pos = IT_CHARPOS (*it);
  7056   int prev_face_id = it->face_id;
  7057 
  7058   eassert (it->sp > 0);
  7059   --it->sp;
  7060   p = it->stack + it->sp;
  7061   it->stop_charpos = p->stop_charpos;
  7062   it->prev_stop = p->prev_stop;
  7063   it->base_level_stop = p->base_level_stop;
  7064   it->cmp_it = p->cmp_it;
  7065   it->face_id = p->face_id;
  7066   it->current = p->current;
  7067   it->position = p->position;
  7068   it->string = p->string;
  7069   it->from_overlay = p->from_overlay;
  7070   if (NILP (it->string))
  7071     SET_TEXT_POS (it->current.string_pos, -1, -1);
  7072   it->method = p->method;
  7073   switch (it->method)
  7074     {
  7075     case GET_FROM_IMAGE:
  7076       it->image_id = p->u.image.image_id;
  7077       it->object = p->u.image.object;
  7078       it->slice = p->u.image.slice;
  7079       break;
  7080     case GET_FROM_XWIDGET:
  7081       it->object = p->u.xwidget.object;
  7082       break;
  7083     case GET_FROM_STRETCH:
  7084       it->object = p->u.stretch.object;
  7085       break;
  7086     case GET_FROM_BUFFER:
  7087       {
  7088         restore_face_box_flags (it, prev_face_id);
  7089         it->object = it->w->contents;
  7090       }
  7091       break;
  7092     case GET_FROM_STRING:
  7093       {
  7094         restore_face_box_flags (it, prev_face_id);
  7095         it->object = it->string;
  7096       }
  7097       break;
  7098     case GET_FROM_DISPLAY_VECTOR:
  7099       if (it->s)
  7100         it->method = GET_FROM_C_STRING;
  7101       else if (STRINGP (it->string))
  7102         it->method = GET_FROM_STRING;
  7103       else
  7104         {
  7105           it->method = GET_FROM_BUFFER;
  7106           it->object = it->w->contents;
  7107         }
  7108       break;
  7109     case GET_FROM_C_STRING:
  7110       break;
  7111     default:
  7112       emacs_abort ();
  7113     }
  7114   it->end_charpos = p->end_charpos;
  7115   it->string_nchars = p->string_nchars;
  7116   it->area = p->area;
  7117   it->multibyte_p = p->multibyte_p;
  7118   it->avoid_cursor_p = p->avoid_cursor_p;
  7119   it->space_width = p->space_width;
  7120   it->font_height = p->font_height;
  7121   it->voffset = p->voffset;
  7122   it->string_from_display_prop_p = p->string_from_display_prop_p;
  7123   it->string_from_prefix_prop_p = p->string_from_prefix_prop_p;
  7124   it->line_wrap = p->line_wrap;
  7125   it->bidi_p = p->bidi_p;
  7126   it->paragraph_embedding = p->paragraph_embedding;
  7127   it->from_disp_prop_p = p->from_disp_prop_p;
  7128   if (it->bidi_p)
  7129     {
  7130       bidi_pop_it (&it->bidi_it);
  7131       /* Bidi-iterate until we get out of the portion of text, if any,
  7132          covered by a `display' text property or by an overlay with
  7133          `display' property.  (We cannot just jump there, because the
  7134          internal coherency of the bidi iterator state can not be
  7135          preserved across such jumps.)  We also must determine the
  7136          paragraph base direction if the overlay we just processed is
  7137          at the beginning of a new paragraph.  */
  7138       if (from_display_prop
  7139           && (it->method == GET_FROM_BUFFER || it->method == GET_FROM_STRING))
  7140         iterate_out_of_display_property (it);
  7141 
  7142       eassert ((BUFFERP (it->object)
  7143                 && IT_CHARPOS (*it) == it->bidi_it.charpos
  7144                 && IT_BYTEPOS (*it) == it->bidi_it.bytepos)
  7145                || (STRINGP (it->object)
  7146                    && IT_STRING_CHARPOS (*it) == it->bidi_it.charpos
  7147                    && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos)
  7148                || (CONSP (it->object) && it->method == GET_FROM_STRETCH)
  7149                /* We could be in the middle of handling a list or a
  7150                   vector of several 'display' properties, in which
  7151                   case we should only verify the above conditions when
  7152                   we pop the iterator stack the last time, because
  7153                   higher stack levels cannot "iterate out of the
  7154                   display property".  */
  7155                || it->sp > 0);
  7156     }
  7157   /* If we move the iterator over text covered by a display property
  7158      to a new buffer position, any info about previously seen overlays
  7159      is no longer valid.  */
  7160   if (from_display_prop && it->sp == 0 && CHARPOS (it->position) != prev_pos)
  7161     it->ignore_overlay_strings_at_pos_p = false;
  7162 }
  7163 
  7164 
  7165 
  7166 /***********************************************************************
  7167                           Moving over lines
  7168  ***********************************************************************/
  7169 
  7170 /* Set IT's current position to the previous line start.  */
  7171 
  7172 static void
  7173 back_to_previous_line_start (struct it *it)
  7174 {
  7175   ptrdiff_t cp = IT_CHARPOS (*it), bp = IT_BYTEPOS (*it);
  7176 
  7177   dec_both (&cp, &bp);
  7178   SET_WITH_NARROWED_BEGV (it, IT_CHARPOS (*it),
  7179                           find_newline_no_quit (cp, bp, -1, &IT_BYTEPOS (*it)),
  7180                           get_small_narrowing_begv (it->w, IT_CHARPOS (*it)));
  7181 }
  7182 
  7183 /* Find in the current buffer the first display or overlay string
  7184    between STARTPOS and ENDPOS that includes embedded newlines.
  7185    Consider only overlays that apply to window W.
  7186    Value is non-zero if such a display/overlay string is found.  */
  7187 static bool
  7188 strings_with_newlines (ptrdiff_t startpos, ptrdiff_t endpos, struct window *w)
  7189 {
  7190   struct itree_node *node;
  7191   /* Process overlays.  */
  7192   ITREE_FOREACH (node, current_buffer->overlays, startpos, endpos, DESCENDING)
  7193     {
  7194       Lisp_Object overlay = node->data;
  7195       eassert (OVERLAYP (overlay));
  7196 
  7197       /* Skip this overlay if it doesn't apply to our window.  */
  7198       Lisp_Object window = Foverlay_get (overlay, Qwindow);
  7199       if (WINDOWP (window) && XWINDOW (window) != w)
  7200         continue;
  7201 
  7202       ptrdiff_t ostart = node->begin;
  7203       ptrdiff_t oend = node->end;
  7204 
  7205       /* Skip overlays that don't overlap the range.  */
  7206       if (!((startpos < oend && ostart < endpos)
  7207             || (ostart == oend
  7208                 && (startpos == oend || (endpos == ZV && oend == endpos)))))
  7209         continue;
  7210 
  7211       Lisp_Object str;
  7212       str = Foverlay_get (overlay, Qbefore_string);
  7213       if (STRINGP (str) && SCHARS (str)
  7214           && memchr (SDATA (str), '\n', SBYTES (str)))
  7215         return true;
  7216       str = Foverlay_get (overlay, Qafter_string);
  7217       if (STRINGP (str) && SCHARS (str)
  7218           && memchr (SDATA (str), '\n', SBYTES (str)))
  7219         return true;
  7220     }
  7221 
  7222   /* Check for 'display' properties whose values include strings.  */
  7223   Lisp_Object cpos = make_fixnum (startpos);
  7224   Lisp_Object limpos = make_fixnum (endpos);
  7225 
  7226   while ((cpos = Fnext_single_property_change (cpos, Qdisplay, Qnil, limpos),
  7227           !(NILP (cpos) || XFIXNAT (cpos) >= endpos)))
  7228     {
  7229       Lisp_Object spec = Fget_char_property (cpos, Qdisplay, Qnil);
  7230       Lisp_Object string = string_from_display_spec (spec);
  7231       if (STRINGP (string)
  7232           && memchr (SDATA (string), '\n', SBYTES (string)))
  7233         return true;
  7234     }
  7235 
  7236   return false;
  7237 }
  7238 
  7239 
  7240 /* Move IT to the next line start.
  7241 
  7242    Value is true if a newline was found.  Set *SKIPPED_P to true if
  7243    we skipped over part of the text (as opposed to moving the iterator
  7244    continuously over the text).  Otherwise, don't change the value
  7245    of *SKIPPED_P.
  7246 
  7247    If BIDI_IT_PREV is non-NULL, store into it the state of the bidi
  7248    iterator on the newline, if it was found.
  7249 
  7250    Newlines may come from buffer text, overlay strings, or strings
  7251    displayed via the `display' property.  That's the reason we can't
  7252    simply use find_newline_no_quit.
  7253 
  7254    Note that this function may not skip over invisible text that is so
  7255    because of text properties and immediately follows a newline.  If
  7256    it would, function reseat_at_next_visible_line_start, when called
  7257    from set_iterator_to_next, would effectively make invisible
  7258    characters following a newline part of the wrong glyph row, which
  7259    leads to wrong cursor motion.  */
  7260 
  7261 static bool
  7262 forward_to_next_line_start (struct it *it, bool *skipped_p,
  7263                             struct bidi_it *bidi_it_prev)
  7264 {
  7265   ptrdiff_t old_selective;
  7266   bool newline_found_p = false;
  7267   int n;
  7268   const int MAX_NEWLINE_DISTANCE = 500;
  7269 
  7270   /* If already on a newline, just consume it to avoid unintended
  7271      skipping over invisible text below.  */
  7272   if (it->what == IT_CHARACTER
  7273       && it->c == '\n'
  7274       && CHARPOS (it->position) == IT_CHARPOS (*it))
  7275     {
  7276       if (it->bidi_p && bidi_it_prev)
  7277         *bidi_it_prev = it->bidi_it;
  7278       set_iterator_to_next (it, false);
  7279       it->c = 0;
  7280       return true;
  7281     }
  7282 
  7283   /* Don't handle selective display in the following.  It's (a)
  7284      unnecessary because it's done by the caller, and (b) leads to an
  7285      infinite recursion because next_element_from_ellipsis indirectly
  7286      calls this function.  */
  7287   old_selective = it->selective;
  7288   it->selective = 0;
  7289 
  7290   /* Scan for a newline within MAX_NEWLINE_DISTANCE display elements
  7291      from buffer text, or till the end of the string if iterating a
  7292      string.  */
  7293   for (n = 0;
  7294        !newline_found_p && n < MAX_NEWLINE_DISTANCE;
  7295        n += !STRINGP (it->string))
  7296     {
  7297       if (!get_next_display_element (it))
  7298         return false;
  7299       newline_found_p = it->what == IT_CHARACTER && it->c == '\n';
  7300       if (newline_found_p && it->bidi_p && bidi_it_prev)
  7301         *bidi_it_prev = it->bidi_it;
  7302       set_iterator_to_next (it, false);
  7303     }
  7304 
  7305   /* If we didn't find a newline near enough, see if we can use a
  7306      short-cut.  */
  7307   if (!newline_found_p)
  7308     {
  7309       ptrdiff_t bytepos, start = IT_CHARPOS (*it);
  7310       ptrdiff_t limit = find_newline_no_quit (start, IT_BYTEPOS (*it),
  7311                                               1, &bytepos);
  7312       eassert (!STRINGP (it->string));
  7313 
  7314       /* it->stop_charpos >= limit means we already know there's no
  7315          stop position up until the newline at LIMIT, so there's no
  7316          need for any further checks.  */
  7317       bool no_strings_with_newlines = it->stop_charpos >= limit;
  7318 
  7319       if (!no_strings_with_newlines)
  7320         {
  7321           if (!(current_buffer->long_line_optimizations_p
  7322                 && it->line_wrap == TRUNCATE))
  7323             {
  7324               /* Quick-and-dirty check: if there isn't any `display'
  7325                  property in sight, and no overlays, we're done.  */
  7326               Lisp_Object pos =
  7327                 Fnext_single_property_change (make_fixnum (start),
  7328                                               Qdisplay, Qnil,
  7329                                               make_fixnum (limit));
  7330               no_strings_with_newlines =
  7331                 (NILP (pos) || XFIXNAT (pos) == limit) /* no 'display' props */
  7332                 && next_overlay_change (start) == ZV;  /* no overlays */
  7333             }
  7334           else
  7335             {
  7336               /* For buffers with very long and truncated lines we try
  7337                  harder, because it's worth our while to spend some
  7338                  time looking into the overlays and 'display' properties
  7339                  if we can then avoid iterating through all of them.  */
  7340               no_strings_with_newlines =
  7341                 !strings_with_newlines (start, limit, it->w);
  7342             }
  7343         }
  7344 
  7345       /* If there's no display or overlay strings with embedded
  7346          newlines until the position of the newline in buffer text, we
  7347          can just use that position.  */
  7348       if (no_strings_with_newlines)
  7349         {
  7350           if (!it->bidi_p || !bidi_it_prev)
  7351             {
  7352               /* The optimal case: just jump there.  */
  7353               IT_CHARPOS (*it) = limit;
  7354               IT_BYTEPOS (*it) = bytepos;
  7355             }
  7356           else
  7357             {
  7358               /* The less optimal case: need to bidi-walk there, but
  7359                  this is still cheaper that the full iteration using
  7360                  get_next_display_element and set_iterator_to_next.  */
  7361               struct bidi_it bprev;
  7362 
  7363               /* Help bidi.c avoid expensive searches for display
  7364                  properties and overlays, by telling it that there are
  7365                  none up to `limit'.  */
  7366               if (it->bidi_it.disp_pos < limit)
  7367                 {
  7368                   it->bidi_it.disp_pos = limit;
  7369                   it->bidi_it.disp_prop = 0;
  7370                 }
  7371               do {
  7372                 bprev = it->bidi_it;
  7373                 bidi_move_to_visually_next (&it->bidi_it);
  7374               } while (it->bidi_it.charpos != limit);
  7375               IT_CHARPOS (*it) = limit;
  7376               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  7377               if (bidi_it_prev)
  7378                 *bidi_it_prev = bprev;
  7379             }
  7380           *skipped_p = newline_found_p = true;
  7381         }
  7382       else
  7383         {
  7384           /* The slow case.  */
  7385           while (!newline_found_p)
  7386             {
  7387               if (!get_next_display_element (it))
  7388                 break;
  7389               newline_found_p = ITERATOR_AT_END_OF_LINE_P (it);
  7390               if (newline_found_p && it->bidi_p && bidi_it_prev)
  7391                 *bidi_it_prev = it->bidi_it;
  7392               set_iterator_to_next (it, false);
  7393             }
  7394         }
  7395     }
  7396 
  7397   it->selective = old_selective;
  7398   return newline_found_p;
  7399 }
  7400 
  7401 
  7402 /* Set IT's current position to the previous visible line start.  Skip
  7403    invisible text that is so either due to text properties or due to
  7404    selective display.  Caution: this does not change IT->current_x and
  7405    IT->hpos.  */
  7406 
  7407 static void
  7408 back_to_previous_visible_line_start (struct it *it)
  7409 {
  7410   while (IT_CHARPOS (*it) > BEGV)
  7411     {
  7412       back_to_previous_line_start (it);
  7413 
  7414       if (IT_CHARPOS (*it) <= BEGV)
  7415         break;
  7416 
  7417       /* If selective > 0, then lines indented more than its value are
  7418          invisible.  */
  7419       if (it->selective > 0
  7420           && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
  7421                                 it->selective))
  7422         continue;
  7423 
  7424       /* Check the newline before point for invisibility.  */
  7425       {
  7426         Lisp_Object prop;
  7427         prop = Fget_char_property (make_fixnum (IT_CHARPOS (*it) - 1),
  7428                                    Qinvisible, it->window);
  7429         if (TEXT_PROP_MEANS_INVISIBLE (prop) != 0)
  7430           continue;
  7431       }
  7432 
  7433       if (IT_CHARPOS (*it) <= BEGV)
  7434         break;
  7435 
  7436       {
  7437         struct it it2;
  7438         void *it2data = NULL;
  7439         ptrdiff_t pos;
  7440         ptrdiff_t beg, end;
  7441         Lisp_Object val, overlay;
  7442 
  7443         SAVE_IT (it2, *it, it2data);
  7444 
  7445         /* If newline is part of a composition, continue from start of composition */
  7446         if (find_composition (IT_CHARPOS (*it), -1, &beg, &end, &val, Qnil)
  7447             && beg < IT_CHARPOS (*it))
  7448           goto replaced;
  7449 
  7450         /* If newline is replaced by a display property, find start of overlay
  7451            or interval and continue search from that point.  */
  7452         pos = --IT_CHARPOS (it2);
  7453         --IT_BYTEPOS (it2);
  7454         it2.sp = 0;
  7455         bidi_unshelve_cache (NULL, false);
  7456         it2.string_from_display_prop_p = false;
  7457         it2.from_disp_prop_p = false;
  7458         if (handle_display_prop (&it2) == HANDLED_RETURN
  7459             && !NILP (val = get_char_property_and_overlay
  7460                       (make_fixnum (pos), Qdisplay, Qnil, &overlay))
  7461             && (OVERLAYP (overlay)
  7462                 ? (beg = OVERLAY_START (overlay))
  7463                 : get_property_and_range (pos, Qdisplay, &val, &beg, &end, Qnil)))
  7464           {
  7465             RESTORE_IT (it, it, it2data);
  7466             goto replaced;
  7467           }
  7468 
  7469         /* Newline is not replaced by anything -- so we are done.  */
  7470         RESTORE_IT (it, it, it2data);
  7471         break;
  7472 
  7473       replaced:
  7474         if (beg < BEGV)
  7475           beg = BEGV;
  7476         IT_CHARPOS (*it) = beg;
  7477         IT_BYTEPOS (*it) = buf_charpos_to_bytepos (current_buffer, beg);
  7478       }
  7479     }
  7480 
  7481   it->continuation_lines_width = 0;
  7482 
  7483   eassert (IT_CHARPOS (*it) >= BEGV);
  7484   eassert (it->medium_narrowing_begv > 0 /* long-line optimizations: all bets off */
  7485            || IT_CHARPOS (*it) == BEGV
  7486            || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
  7487   CHECK_IT (it);
  7488 }
  7489 
  7490 
  7491 /* Reseat iterator IT at the previous visible line start.  Skip
  7492    invisible text that is so either due to text properties or due to
  7493    selective display.  At the end, update IT's overlay information,
  7494    face information etc.  */
  7495 
  7496 void
  7497 reseat_at_previous_visible_line_start (struct it *it)
  7498 {
  7499   back_to_previous_visible_line_start (it);
  7500   reseat (it, it->current.pos, true);
  7501   CHECK_IT (it);
  7502 }
  7503 
  7504 
  7505 /* Reseat iterator IT on the next visible line start in the current
  7506    buffer.  ON_NEWLINE_P means position IT on the newline
  7507    preceding the line start.  Skip over invisible text that is so
  7508    because of selective display.  Compute faces, overlays etc at the
  7509    new position.  Note that this function does not skip over text that
  7510    is invisible because of text properties.  */
  7511 
  7512 static void
  7513 reseat_at_next_visible_line_start (struct it *it, bool on_newline_p)
  7514 {
  7515   bool skipped_p = false;
  7516   struct bidi_it bidi_it_prev;
  7517   bool newline_found_p
  7518     = forward_to_next_line_start (it, &skipped_p,
  7519                                   on_newline_p ? &bidi_it_prev : NULL);
  7520 
  7521   /* Skip over lines that are invisible because they are indented
  7522      more than the value of IT->selective.  */
  7523   if (it->selective > 0)
  7524     while (IT_CHARPOS (*it) < ZV
  7525            && indented_beyond_p (IT_CHARPOS (*it), IT_BYTEPOS (*it),
  7526                                  it->selective))
  7527       {
  7528         eassert (IT_BYTEPOS (*it) == BEGV
  7529                  || FETCH_BYTE (IT_BYTEPOS (*it) - 1) == '\n');
  7530         newline_found_p =
  7531           forward_to_next_line_start (it, &skipped_p,
  7532                                       on_newline_p ? &bidi_it_prev : NULL);
  7533       }
  7534 
  7535   /* Position on the newline if that's what's requested.  */
  7536   if (on_newline_p && newline_found_p)
  7537     {
  7538       if (STRINGP (it->string))
  7539         {
  7540           if (IT_STRING_CHARPOS (*it) > 0)
  7541             {
  7542               if (!it->bidi_p)
  7543                 {
  7544                   --IT_STRING_CHARPOS (*it);
  7545                   --IT_STRING_BYTEPOS (*it);
  7546                 }
  7547               else
  7548                 {
  7549                   /* We need to restore the bidi iterator to the state
  7550                      it had on the newline, and resync the IT's
  7551                      position with that.  */
  7552                   it->bidi_it = bidi_it_prev;
  7553                   IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  7554                   IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  7555                 }
  7556             }
  7557         }
  7558       else if (IT_CHARPOS (*it) > BEGV)
  7559         {
  7560           if (!it->bidi_p)
  7561             {
  7562               --IT_CHARPOS (*it);
  7563               --IT_BYTEPOS (*it);
  7564             }
  7565           else
  7566             {
  7567               /* We need to restore the bidi iterator to the state it
  7568                  had on the newline and resync IT with that.  */
  7569               it->bidi_it = bidi_it_prev;
  7570               IT_CHARPOS (*it) = it->bidi_it.charpos;
  7571               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  7572             }
  7573           reseat (it, it->current.pos, false);
  7574         }
  7575     }
  7576   else if (skipped_p)
  7577     reseat (it, it->current.pos, false);
  7578 
  7579   CHECK_IT (it);
  7580 }
  7581 
  7582 
  7583 
  7584 /***********************************************************************
  7585                    Changing an iterator's position
  7586 ***********************************************************************/
  7587 
  7588 /* Change IT's current position to POS in current_buffer.
  7589    If FORCE_P, always check for text properties at the new position.
  7590    Otherwise, text properties are only looked up if POS >=
  7591    IT->check_charpos of a property.  */
  7592 
  7593 static void
  7594 reseat (struct it *it, struct text_pos pos, bool force_p)
  7595 {
  7596   ptrdiff_t original_pos = IT_CHARPOS (*it);
  7597 
  7598   reseat_1 (it, pos, false);
  7599 
  7600   if (current_buffer->long_line_optimizations_p)
  7601     {
  7602       if (!it->medium_narrowing_begv)
  7603         {
  7604           it->medium_narrowing_begv
  7605             = get_medium_narrowing_begv (it->w, window_point (it->w));
  7606           it->medium_narrowing_zv
  7607             = get_medium_narrowing_zv (it->w, window_point (it->w));
  7608           it->large_narrowing_begv
  7609             = get_large_narrowing_begv (window_point (it->w));
  7610           it->large_narrowing_zv
  7611             = get_large_narrowing_zv (window_point (it->w));
  7612         }
  7613       else if ((pos.charpos < it->medium_narrowing_begv
  7614                 || pos.charpos > it->medium_narrowing_zv)
  7615                 && (!redisplaying_p || it->line_wrap == TRUNCATE))
  7616         {
  7617           it->medium_narrowing_begv
  7618             = get_medium_narrowing_begv (it->w, pos.charpos);
  7619           it->medium_narrowing_zv
  7620             = get_medium_narrowing_zv (it->w, pos.charpos);
  7621           it->large_narrowing_begv
  7622             = get_large_narrowing_begv (window_point (it->w));
  7623           it->large_narrowing_zv
  7624             = get_large_narrowing_zv (window_point (it->w));
  7625         }
  7626     }
  7627 
  7628   /* Determine where to check text properties.  Avoid doing it
  7629      where possible because text property lookup is very expensive.  */
  7630   if (force_p
  7631       || CHARPOS (pos) > it->stop_charpos
  7632       || CHARPOS (pos) < original_pos)
  7633     {
  7634       if (it->bidi_p)
  7635         {
  7636           /* For bidi iteration, we need to prime prev_stop and
  7637              base_level_stop with our best estimations.  */
  7638           /* Implementation note: Of course, POS is not necessarily a
  7639              stop position, so assigning prev_pos to it is a lie; we
  7640              should have called compute_stop_backwards.  However, if
  7641              the current buffer does not include any R2L characters,
  7642              that call would be a waste of cycles, because the
  7643              iterator will never move back, and thus never cross this
  7644              "fake" stop position.  So we delay that backward search
  7645              until the time we really need it, in next_element_from_buffer.  */
  7646           if (CHARPOS (pos) != it->prev_stop)
  7647             it->prev_stop = CHARPOS (pos);
  7648           if (CHARPOS (pos) < it->base_level_stop)
  7649             it->base_level_stop = 0; /* meaning it's unknown */
  7650           handle_stop (it);
  7651         }
  7652       else
  7653         {
  7654           handle_stop (it);
  7655           it->prev_stop = it->base_level_stop = 0;
  7656         }
  7657 
  7658     }
  7659 
  7660   CHECK_IT (it);
  7661 }
  7662 
  7663 
  7664 /* Change IT's buffer position to POS.  SET_STOP_P means set
  7665    IT->stop_pos to POS, also.  */
  7666 
  7667 static void
  7668 reseat_1 (struct it *it, struct text_pos pos, bool set_stop_p)
  7669 {
  7670   /* Don't call this function when scanning a C string.  */
  7671   eassert (it->s == NULL);
  7672 
  7673   /* POS must be a reasonable value.  */
  7674   eassert (CHARPOS (pos) >= BEGV && CHARPOS (pos) <= ZV);
  7675 
  7676   it->current.pos = it->position = pos;
  7677   it->end_charpos = ZV;
  7678   it->dpvec = NULL;
  7679   it->current.dpvec_index = -1;
  7680   it->current.overlay_string_index = -1;
  7681   IT_STRING_CHARPOS (*it) = -1;
  7682   IT_STRING_BYTEPOS (*it) = -1;
  7683   it->string = Qnil;
  7684   it->method = GET_FROM_BUFFER;
  7685   it->object = it->w->contents;
  7686   it->area = TEXT_AREA;
  7687   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
  7688   it->sp = 0;
  7689   it->string_from_display_prop_p = false;
  7690   it->string_from_prefix_prop_p = false;
  7691 
  7692   it->from_disp_prop_p = false;
  7693   it->face_before_selective_p = false;
  7694   if (it->bidi_p)
  7695     {
  7696       bidi_init_it (IT_CHARPOS (*it), IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
  7697                     &it->bidi_it);
  7698       bidi_unshelve_cache (NULL, false);
  7699       it->bidi_it.paragraph_dir = NEUTRAL_DIR;
  7700       it->bidi_it.string.s = NULL;
  7701       it->bidi_it.string.lstring = Qnil;
  7702       it->bidi_it.string.bufpos = 0;
  7703       it->bidi_it.string.from_disp_str = false;
  7704       it->bidi_it.string.unibyte = false;
  7705       it->bidi_it.w = it->w;
  7706     }
  7707 
  7708   if (set_stop_p)
  7709     {
  7710       it->stop_charpos = CHARPOS (pos);
  7711       it->base_level_stop = CHARPOS (pos);
  7712     }
  7713   /* This make the information stored in it->cmp_it invalidate.  */
  7714   it->cmp_it.id = -1;
  7715   it->min_width_property = Qnil;
  7716 }
  7717 
  7718 
  7719 /* Set up IT for displaying a string, starting at CHARPOS in window W.
  7720    If S is non-null, it is a C string to iterate over.  Otherwise,
  7721    STRING gives a Lisp string to iterate over.
  7722 
  7723    If PRECISION > 0, don't return more then PRECISION number of
  7724    characters from the string.
  7725 
  7726    If FIELD_WIDTH > 0, return padding spaces until FIELD_WIDTH
  7727    characters have been returned.  FIELD_WIDTH < 0 means an infinite
  7728    field width.
  7729 
  7730    MULTIBYTE = 0 means disable processing of multibyte characters,
  7731    MULTIBYTE > 0 means enable it,
  7732    MULTIBYTE < 0 means use IT->multibyte_p.
  7733 
  7734    IT must be initialized via a prior call to init_iterator before
  7735    calling this function.  */
  7736 
  7737 static void
  7738 reseat_to_string (struct it *it, const char *s, Lisp_Object string,
  7739                   ptrdiff_t charpos, ptrdiff_t precision, int field_width,
  7740                   int multibyte)
  7741 {
  7742   /* No text property checks performed by default, but see below.  */
  7743   it->stop_charpos = -1;
  7744 
  7745   /* Set iterator position and end position.  */
  7746   memset (&it->current, 0, sizeof it->current);
  7747   it->current.overlay_string_index = -1;
  7748   it->current.dpvec_index = -1;
  7749   eassert (charpos >= 0);
  7750 
  7751   /* If STRING is specified, use its multibyteness, otherwise use the
  7752      setting of MULTIBYTE, if specified.  */
  7753   if (multibyte >= 0)
  7754     it->multibyte_p = multibyte > 0;
  7755 
  7756   /* Bidirectional reordering of strings is controlled by the default
  7757      value of bidi-display-reordering.  Don't try to reorder while
  7758      loading loadup.el, as the necessary character property tables are
  7759      not yet available.  */
  7760   it->bidi_p =
  7761     !redisplay__inhibit_bidi
  7762     && !NILP (BVAR (&buffer_defaults, bidi_display_reordering));
  7763 
  7764   if (s == NULL)
  7765     {
  7766       eassert (STRINGP (string));
  7767       it->string = string;
  7768       it->s = NULL;
  7769       it->end_charpos = it->string_nchars = SCHARS (string);
  7770       it->method = GET_FROM_STRING;
  7771       it->current.string_pos = string_pos (charpos, string);
  7772 
  7773       if (it->bidi_p)
  7774         {
  7775           it->bidi_it.string.lstring = string;
  7776           it->bidi_it.string.s = NULL;
  7777           it->bidi_it.string.schars = it->end_charpos;
  7778           it->bidi_it.string.bufpos = 0;
  7779           it->bidi_it.string.from_disp_str = false;
  7780           it->bidi_it.string.unibyte = !it->multibyte_p;
  7781           it->bidi_it.w = it->w;
  7782           bidi_init_it (charpos, IT_STRING_BYTEPOS (*it),
  7783                         FRAME_WINDOW_P (it->f), &it->bidi_it);
  7784         }
  7785     }
  7786   else
  7787     {
  7788       it->s = (const unsigned char *) s;
  7789       it->string = Qnil;
  7790 
  7791       /* Note that we use IT->current.pos, not it->current.string_pos,
  7792          for displaying C strings.  */
  7793       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = -1;
  7794       if (it->multibyte_p)
  7795         {
  7796           it->current.pos = c_string_pos (charpos, s, true);
  7797           it->end_charpos = it->string_nchars = number_of_chars (s, true);
  7798         }
  7799       else
  7800         {
  7801           IT_CHARPOS (*it) = IT_BYTEPOS (*it) = charpos;
  7802           it->end_charpos = it->string_nchars = strlen (s);
  7803         }
  7804 
  7805       if (it->bidi_p)
  7806         {
  7807           it->bidi_it.string.lstring = Qnil;
  7808           it->bidi_it.string.s = (const unsigned char *) s;
  7809           it->bidi_it.string.schars = it->end_charpos;
  7810           it->bidi_it.string.bufpos = 0;
  7811           it->bidi_it.string.from_disp_str = false;
  7812           it->bidi_it.string.unibyte = !it->multibyte_p;
  7813           it->bidi_it.w = it->w;
  7814           bidi_init_it (charpos, IT_BYTEPOS (*it), FRAME_WINDOW_P (it->f),
  7815                         &it->bidi_it);
  7816         }
  7817       it->method = GET_FROM_C_STRING;
  7818     }
  7819 
  7820   /* PRECISION > 0 means don't return more than PRECISION characters
  7821      from the string.  */
  7822   if (precision > 0 && it->end_charpos - charpos > precision)
  7823     {
  7824       it->end_charpos = it->string_nchars = charpos + precision;
  7825       if (it->bidi_p)
  7826         it->bidi_it.string.schars = it->end_charpos;
  7827     }
  7828 
  7829   /* FIELD_WIDTH > 0 means pad with spaces until FIELD_WIDTH
  7830      characters have been returned.  FIELD_WIDTH == 0 means don't pad,
  7831      FIELD_WIDTH < 0 means infinite field width.  This is useful for
  7832      padding with `-' at the end of a mode line.  */
  7833   if (field_width < 0)
  7834     field_width = DISP_INFINITY;
  7835   /* Implementation note: We deliberately don't enlarge
  7836      it->bidi_it.string.schars here to fit it->end_charpos, because
  7837      the bidi iterator cannot produce characters out of thin air.  */
  7838   if (field_width > it->end_charpos - charpos)
  7839     it->end_charpos = charpos + field_width;
  7840 
  7841   /* Use the standard display table for displaying strings.  */
  7842   if (DISP_TABLE_P (Vstandard_display_table))
  7843     it->dp = XCHAR_TABLE (Vstandard_display_table);
  7844 
  7845   it->stop_charpos = charpos;
  7846   it->prev_stop = charpos;
  7847   it->base_level_stop = 0;
  7848   if (it->bidi_p)
  7849     {
  7850       it->bidi_it.first_elt = true;
  7851       it->bidi_it.paragraph_dir = NEUTRAL_DIR;
  7852       it->bidi_it.disp_pos = -1;
  7853     }
  7854   if (s == NULL && it->multibyte_p)
  7855     {
  7856       ptrdiff_t endpos = SCHARS (it->string);
  7857       if (endpos > it->end_charpos)
  7858         endpos = it->end_charpos;
  7859       composition_compute_stop_pos (&it->cmp_it, charpos, -1, endpos,
  7860                                     it->string, true);
  7861     }
  7862   CHECK_IT (it);
  7863 }
  7864 
  7865 
  7866 
  7867 /***********************************************************************
  7868                               Iteration
  7869 ***********************************************************************/
  7870 
  7871 /* Map enum it_method value to corresponding next_element_from_* function.  */
  7872 
  7873 typedef bool (*next_element_function) (struct it *);
  7874 
  7875 static next_element_function const get_next_element[NUM_IT_METHODS] =
  7876 {
  7877   next_element_from_buffer,
  7878   next_element_from_display_vector,
  7879   next_element_from_string,
  7880   next_element_from_c_string,
  7881   next_element_from_image,
  7882   next_element_from_stretch,
  7883   next_element_from_xwidget,
  7884 };
  7885 
  7886 #define GET_NEXT_DISPLAY_ELEMENT(it) (*get_next_element[(it)->method]) (it)
  7887 
  7888 
  7889 /* Return true iff a character at CHARPOS (and BYTEPOS) is composed
  7890    (possibly with the following characters).
  7891 
  7892   Note: we pass -1 as the "resolved bidi level" when the iterator
  7893   doesn't have the bidi_p flag set, because in that case we really
  7894   don't know what is the directionality of the text, so we leave it to
  7895   the shaping engine to figure that out.  */
  7896 
  7897 #define CHAR_COMPOSED_P(IT,CHARPOS,BYTEPOS,END_CHARPOS)                 \
  7898   ((IT)->cmp_it.id >= 0                                                 \
  7899    || ((IT)->cmp_it.stop_pos == (CHARPOS)                               \
  7900        && composition_reseat_it (&(IT)->cmp_it, CHARPOS, BYTEPOS,       \
  7901                                  END_CHARPOS, (IT)->w,                  \
  7902                                  (IT)->bidi_p                           \
  7903                                  ? (IT)->bidi_it.resolved_level         \
  7904                                  : -1,                                  \
  7905                                  FACE_FROM_ID_OR_NULL ((IT)->f,         \
  7906                                                        (IT)->face_id),  \
  7907                                  (IT)->string)))
  7908 
  7909 
  7910 /* Lookup the char-table Vglyphless_char_display for character C (-1
  7911    if we want information for no-font case), and return the display
  7912    method symbol.  By side-effect, update it->what and
  7913    it->glyphless_method.  This function is called from
  7914    get_next_display_element for each character element, and from
  7915    gui_produce_glyphs when no suitable font was found.  */
  7916 
  7917 Lisp_Object
  7918 lookup_glyphless_char_display (int c, struct it *it)
  7919 {
  7920   Lisp_Object glyphless_method = Qnil;
  7921 
  7922   if (CHAR_TABLE_P (Vglyphless_char_display)
  7923       && CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display)) >= 1)
  7924     {
  7925       if (c >= 0)
  7926         glyphless_method = CHAR_TABLE_REF (Vglyphless_char_display, c);
  7927       else
  7928         glyphless_method = XCHAR_TABLE (Vglyphless_char_display)->extras[0];
  7929 
  7930       if (CONSP (glyphless_method))
  7931         glyphless_method = FRAME_WINDOW_P (it->f)
  7932           ? XCAR (glyphless_method)
  7933           : XCDR (glyphless_method);
  7934     }
  7935 
  7936  retry:
  7937   if (NILP (glyphless_method))
  7938     {
  7939       if (c >= 0)
  7940         /* The default is to display the character by a proper font.  */
  7941         return Qnil;
  7942       /* The default for the no-font case is to display an empty box.  */
  7943       glyphless_method = Qempty_box;
  7944     }
  7945   if (EQ (glyphless_method, Qzero_width))
  7946     {
  7947       if (c >= 0)
  7948         return glyphless_method;
  7949       /* This method can't be used for the no-font case.  */
  7950       glyphless_method = Qempty_box;
  7951     }
  7952   if (EQ (glyphless_method, Qthin_space))
  7953     it->glyphless_method = GLYPHLESS_DISPLAY_THIN_SPACE;
  7954   else if (EQ (glyphless_method, Qempty_box))
  7955     it->glyphless_method = GLYPHLESS_DISPLAY_EMPTY_BOX;
  7956   else if (EQ (glyphless_method, Qhex_code))
  7957     it->glyphless_method = GLYPHLESS_DISPLAY_HEX_CODE;
  7958   else if (STRINGP (glyphless_method))
  7959     it->glyphless_method = GLYPHLESS_DISPLAY_ACRONYM;
  7960   else
  7961     {
  7962       /* Invalid value.  We use the default method.  */
  7963       glyphless_method = Qnil;
  7964       goto retry;
  7965     }
  7966   it->what = IT_GLYPHLESS;
  7967   return glyphless_method;
  7968 }
  7969 
  7970 /* Merge escape glyph face and cache the result.  */
  7971 
  7972 static struct frame *last_escape_glyph_frame = NULL;
  7973 static int last_escape_glyph_face_id = (1 << FACE_ID_BITS);
  7974 static int last_escape_glyph_merged_face_id = 0;
  7975 
  7976 static int
  7977 merge_escape_glyph_face (struct it *it)
  7978 {
  7979   int face_id;
  7980 
  7981   if (it->f == last_escape_glyph_frame
  7982       && it->face_id == last_escape_glyph_face_id)
  7983     face_id = last_escape_glyph_merged_face_id;
  7984   else
  7985     {
  7986       /* Merge the `escape-glyph' face into the current face.  */
  7987       face_id = merge_faces (it->w, Qescape_glyph, 0, it->face_id);
  7988       last_escape_glyph_frame = it->f;
  7989       last_escape_glyph_face_id = it->face_id;
  7990       last_escape_glyph_merged_face_id = face_id;
  7991     }
  7992   return face_id;
  7993 }
  7994 
  7995 /* Likewise for glyphless glyph face.  */
  7996 
  7997 static struct frame *last_glyphless_glyph_frame = NULL;
  7998 static int last_glyphless_glyph_face_id = (1 << FACE_ID_BITS);
  7999 static int last_glyphless_glyph_merged_face_id = 0;
  8000 
  8001 int
  8002 merge_glyphless_glyph_face (struct it *it)
  8003 {
  8004   int face_id;
  8005 
  8006   if (it->f == last_glyphless_glyph_frame
  8007       && it->face_id == last_glyphless_glyph_face_id)
  8008     face_id = last_glyphless_glyph_merged_face_id;
  8009   else
  8010     {
  8011       /* Merge the `glyphless-char' face into the current face.  */
  8012       face_id = merge_faces (it->w, Qglyphless_char, 0, it->face_id);
  8013       last_glyphless_glyph_frame = it->f;
  8014       last_glyphless_glyph_face_id = it->face_id;
  8015       last_glyphless_glyph_merged_face_id = face_id;
  8016     }
  8017   return face_id;
  8018 }
  8019 
  8020 /* Forget the `escape-glyph' and `glyphless-char' faces.  This should
  8021    be called before redisplaying windows, and when the frame's face
  8022    cache is freed.  */
  8023 void
  8024 forget_escape_and_glyphless_faces (void)
  8025 {
  8026   last_escape_glyph_frame = NULL;
  8027   last_escape_glyph_face_id = (1 << FACE_ID_BITS);
  8028   last_glyphless_glyph_frame = NULL;
  8029   last_glyphless_glyph_face_id = (1 << FACE_ID_BITS);
  8030 }
  8031 
  8032 /* Load IT's display element fields with information about the next
  8033    display element from the current position of IT.  Value is false if
  8034    end of buffer (or C string) is reached.  */
  8035 
  8036 static bool
  8037 get_next_display_element (struct it *it)
  8038 {
  8039   /* True means that we found a display element.  False means that
  8040      we hit the end of what we iterate over.  Performance note: the
  8041      function pointer `method' used here turns out to be faster than
  8042      using a sequence of if-statements.  */
  8043   bool success_p;
  8044 
  8045  get_next:
  8046   success_p = GET_NEXT_DISPLAY_ELEMENT (it);
  8047 
  8048   if (it->what == IT_CHARACTER)
  8049     {
  8050       /* UAX#9, L4: "A character is depicted by a mirrored glyph if
  8051          and only if (a) the resolved directionality of that character
  8052          is R..."  */
  8053       /* FIXME: Do we need an exception for characters from display
  8054          tables?  */
  8055       if (it->bidi_p && it->bidi_it.type == STRONG_R
  8056           && !inhibit_bidi_mirroring)
  8057         it->c = bidi_mirror_char (it->c);
  8058       /* Map via display table or translate control characters.
  8059          IT->c, IT->len etc. have been set to the next character by
  8060          the function call above.  If we have a display table, and it
  8061          contains an entry for IT->c, translate it.  Don't do this if
  8062          IT->c itself comes from a display table, otherwise we could
  8063          end up in an infinite recursion.  (An alternative could be to
  8064          count the recursion depth of this function and signal an
  8065          error when a certain maximum depth is reached.)  Is it worth
  8066          it?  */
  8067       if (success_p && it->dpvec == NULL)
  8068         {
  8069           Lisp_Object dv;
  8070           struct charset *unibyte = CHARSET_FROM_ID (charset_unibyte);
  8071           bool nonascii_space_p = false;
  8072           bool nonascii_hyphen_p = false;
  8073           int c = it->c;        /* This is the character to display.  */
  8074 
  8075           if (! it->multibyte_p && ! ASCII_CHAR_P (c))
  8076             {
  8077               eassert (SINGLE_BYTE_CHAR_P (c));
  8078               if (unibyte_display_via_language_environment)
  8079                 {
  8080                   c = DECODE_CHAR (unibyte, c);
  8081                   if (c < 0)
  8082                     c = BYTE8_TO_CHAR (it->c);
  8083                 }
  8084               else
  8085                 c = BYTE8_TO_CHAR (it->c);
  8086             }
  8087 
  8088           if (it->dp
  8089               && (dv = DISP_CHAR_VECTOR (it->dp, c),
  8090                   VECTORP (dv)))
  8091             {
  8092               struct Lisp_Vector *v = XVECTOR (dv);
  8093 
  8094               /* Return the first character from the display table
  8095                  entry, if not empty.  If empty, don't display the
  8096                  current character.  */
  8097               if (v->header.size)
  8098                 {
  8099                   it->dpvec_char_len = it->len;
  8100                   it->dpvec = v->contents;
  8101                   it->dpend = v->contents + v->header.size;
  8102                   it->current.dpvec_index = 0;
  8103                   it->dpvec_face_id = -1;
  8104                   it->saved_face_id = it->face_id;
  8105                   it->method = GET_FROM_DISPLAY_VECTOR;
  8106                   it->ellipsis_p = false;
  8107                 }
  8108               else
  8109                 {
  8110                   set_iterator_to_next (it, false);
  8111                 }
  8112               goto get_next;
  8113             }
  8114 
  8115           if (! NILP (lookup_glyphless_char_display (c, it)))
  8116             {
  8117               if (it->what == IT_GLYPHLESS)
  8118                 goto done;
  8119               /* Don't display this character.  */
  8120               set_iterator_to_next (it, false);
  8121               goto get_next;
  8122             }
  8123 
  8124           /* If `nobreak-char-display' is non-nil, we display
  8125              non-ASCII spaces and hyphens specially.  */
  8126           if (! ASCII_CHAR_P (c) && ! NILP (Vnobreak_char_display))
  8127             {
  8128               if (blankp (c))
  8129                 nonascii_space_p = true;
  8130               else if (c == SOFT_HYPHEN || c == HYPHEN
  8131                        || c == NON_BREAKING_HYPHEN)
  8132                 nonascii_hyphen_p = true;
  8133             }
  8134 
  8135           /* Translate control characters into `\003' or `^C' form.
  8136              Control characters coming from a display table entry are
  8137              currently not translated because we use IT->dpvec to hold
  8138              the translation.  This could easily be changed but I
  8139              don't believe that it is worth doing.
  8140 
  8141              The characters handled by `nobreak-char-display' must be
  8142              translated too.
  8143 
  8144              Non-printable characters and raw-byte characters are also
  8145              translated to octal or hexadecimal form.  */
  8146           if (((c < ' ' || c == 127) /* ASCII control chars.  */
  8147                ? (it->area != TEXT_AREA
  8148                   /* In mode line, treat \n, \t like other crl chars.  */
  8149                   || (c != '\t'
  8150                       && it->glyph_row
  8151                       && (it->glyph_row->mode_line_p || it->avoid_cursor_p))
  8152                   || (c != '\n' && c != '\t'))
  8153                : (nonascii_space_p
  8154                   || nonascii_hyphen_p
  8155                   || CHAR_BYTE8_P (c)
  8156                   || ! CHAR_PRINTABLE_P (c))))
  8157             {
  8158               /* C is a control character, non-ASCII space/hyphen,
  8159                  raw-byte, or a non-printable character which must be
  8160                  displayed either as '\003' or as `^C' where the '\\'
  8161                  and '^' can be defined in the display table.  Fill
  8162                  IT->ctl_chars with glyphs for what we have to
  8163                  display.  Then, set IT->dpvec to these glyphs.  */
  8164               Lisp_Object gc;
  8165               int ctl_len;
  8166               int face_id;
  8167               int lface_id = 0;
  8168               int escape_glyph;
  8169 
  8170               /* Handle control characters with ^.  */
  8171 
  8172               if (ASCII_CHAR_P (c) && it->ctl_arrow_p)
  8173                 {
  8174                   int g;
  8175 
  8176                   g = '^';           /* default glyph for Control */
  8177                   /* Set IT->ctl_chars[0] to the glyph for `^'.  */
  8178                   if (it->dp
  8179                       && (gc = DISP_CTRL_GLYPH (it->dp), GLYPH_CODE_P (gc)))
  8180                     {
  8181                       g = GLYPH_CODE_CHAR (gc);
  8182                       lface_id = GLYPH_CODE_FACE (gc);
  8183                     }
  8184 
  8185                   face_id = (lface_id
  8186                              ? merge_faces (it->w, Qt, lface_id, it->face_id)
  8187                              : merge_escape_glyph_face (it));
  8188 
  8189                   XSETINT (it->ctl_chars[0], g);
  8190                   XSETINT (it->ctl_chars[1], c ^ 0100);
  8191                   ctl_len = 2;
  8192                   goto display_control;
  8193                 }
  8194 
  8195               /* Handle non-ascii space in the mode where it only gets
  8196                  highlighting.  */
  8197 
  8198               if (nonascii_space_p && EQ (Vnobreak_char_display, Qt))
  8199                 {
  8200                   /* Merge `nobreak-space' into the current face.  */
  8201                   face_id = merge_faces (it->w, Qnobreak_space, 0,
  8202                                          it->face_id);
  8203                   XSETINT (it->ctl_chars[0],
  8204                            nobreak_char_ascii_display ? ' ' : it->c);
  8205                   ctl_len = 1;
  8206                   goto display_control;
  8207                 }
  8208 
  8209               /* Handle non-ascii hyphens in the mode where it only
  8210                  gets highlighting.  */
  8211 
  8212               if (nonascii_hyphen_p && EQ (Vnobreak_char_display, Qt))
  8213                 {
  8214                   /* Merge `nobreak-space' into the current face.  */
  8215                   face_id = merge_faces (it->w, Qnobreak_hyphen, 0,
  8216                                          it->face_id);
  8217                   XSETINT (it->ctl_chars[0],
  8218                            nobreak_char_ascii_display ? '-' : it->c);
  8219                   ctl_len = 1;
  8220                   goto display_control;
  8221                 }
  8222 
  8223               /* Handle sequences that start with the "escape glyph".  */
  8224 
  8225               /* the default escape glyph is \.  */
  8226               escape_glyph = '\\';
  8227 
  8228               if (it->dp
  8229                   && (gc = DISP_ESCAPE_GLYPH (it->dp), GLYPH_CODE_P (gc)))
  8230                 {
  8231                   escape_glyph = GLYPH_CODE_CHAR (gc);
  8232                   lface_id = GLYPH_CODE_FACE (gc);
  8233                 }
  8234 
  8235               face_id = (lface_id
  8236                          ? merge_faces (it->w, Qt, lface_id, it->face_id)
  8237                          : merge_escape_glyph_face (it));
  8238 
  8239               /* Draw non-ASCII space/hyphen with escape glyph: */
  8240 
  8241               if (nonascii_space_p || nonascii_hyphen_p)
  8242                 {
  8243                   XSETINT (it->ctl_chars[0], escape_glyph);
  8244                   XSETINT (it->ctl_chars[1], nonascii_space_p ? ' ' : '-');
  8245                   ctl_len = 2;
  8246                   goto display_control;
  8247                 }
  8248 
  8249               {
  8250                 char str[10];
  8251                 int len, i;
  8252 
  8253                 if (CHAR_BYTE8_P (c))
  8254                   /* Display \200 or \x80 instead of \17777600.  */
  8255                   c = CHAR_TO_BYTE8 (c);
  8256                 const char *format_string = display_raw_bytes_as_hex
  8257                                             ? "x%02x"
  8258                                             : "%03o";
  8259                 len = sprintf (str, format_string, c + 0u);
  8260 
  8261                 XSETINT (it->ctl_chars[0], escape_glyph);
  8262                 for (i = 0; i < len; i++)
  8263                   XSETINT (it->ctl_chars[i + 1], str[i]);
  8264                 ctl_len = len + 1;
  8265               }
  8266 
  8267             display_control:
  8268               /* Set up IT->dpvec and return first character from it.  */
  8269               it->dpvec_char_len = it->len;
  8270               it->dpvec = it->ctl_chars;
  8271               it->dpend = it->dpvec + ctl_len;
  8272               it->current.dpvec_index = 0;
  8273               it->dpvec_face_id = face_id;
  8274               it->saved_face_id = it->face_id;
  8275               it->method = GET_FROM_DISPLAY_VECTOR;
  8276               it->ellipsis_p = false;
  8277               goto get_next;
  8278             }
  8279           it->char_to_display = c;
  8280         }
  8281       else if (success_p)
  8282         {
  8283           it->char_to_display = it->c;
  8284         }
  8285     }
  8286 
  8287 #ifdef HAVE_WINDOW_SYSTEM
  8288   /* Adjust face id for a multibyte character.  There are no multibyte
  8289      character in unibyte text.  */
  8290   if ((it->what == IT_CHARACTER || it->what == IT_COMPOSITION)
  8291       && it->multibyte_p
  8292       && success_p
  8293       && FRAME_WINDOW_P (it->f))
  8294     {
  8295       struct face *face = FACE_FROM_ID (it->f, it->face_id);
  8296 
  8297       if (it->what == IT_COMPOSITION && it->cmp_it.ch >= 0)
  8298         {
  8299           /* Automatic composition with glyph-string.   */
  8300           Lisp_Object gstring = composition_gstring_from_id (it->cmp_it.id);
  8301 
  8302           it->face_id = face_for_font (it->f, LGSTRING_FONT (gstring), face);
  8303         }
  8304       else
  8305         {
  8306           ptrdiff_t pos = (it->s ? -1
  8307                      : STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
  8308                      : IT_CHARPOS (*it));
  8309           int c;
  8310 
  8311           if (it->what == IT_CHARACTER)
  8312             c = it->char_to_display;
  8313           else
  8314             {
  8315               struct composition *cmp = composition_table[it->cmp_it.id];
  8316               int i;
  8317 
  8318               c = ' ';
  8319               for (i = 0; i < cmp->glyph_len; i++)
  8320                 /* TAB in a composition means display glyphs with
  8321                    padding space on the left or right.  */
  8322                 if ((c = COMPOSITION_GLYPH (cmp, i)) != '\t')
  8323                   break;
  8324             }
  8325           it->face_id = FACE_FOR_CHAR (it->f, face, c, pos, it->string);
  8326         }
  8327     }
  8328 #endif  /* HAVE_WINDOW_SYSTEM */
  8329 
  8330  done:
  8331   /* Is this character the last one of a run of characters with
  8332      box?  If yes, set IT->end_of_box_run_p to true.  */
  8333   if (it->face_box_p
  8334       && it->s == NULL)
  8335     {
  8336       if (it->method == GET_FROM_STRING && it->sp)
  8337         {
  8338           int face_id = underlying_face_id (it);
  8339           struct face *face = FACE_FROM_ID_OR_NULL (it->f, face_id);
  8340 
  8341           if (face)
  8342             {
  8343               if (face->box == FACE_NO_BOX)
  8344                 {
  8345                   /* If the box comes from face properties in a
  8346                      display string, check faces in that string.  */
  8347                   int string_face_id = face_after_it_pos (it);
  8348                   if (FACE_FROM_ID (it->f, string_face_id)->box == FACE_NO_BOX)
  8349                     it->end_of_box_run_p = true;
  8350                 }
  8351               /* Otherwise, the box comes from the underlying face.
  8352                  If this is the last string character displayed, check
  8353                  the next buffer location.  */
  8354               else if (((IT_STRING_CHARPOS (*it) >= SCHARS (it->string) - 1)
  8355                         /* For a composition, see if the string ends
  8356                            at the last character included in the
  8357                            composition.  */
  8358                         || (it->what == IT_COMPOSITION
  8359                             && (IT_STRING_CHARPOS (*it) + it->cmp_it.nchars
  8360                                 >= SCHARS (it->string))))
  8361                        /* n_overlay_strings is unreliable unless
  8362                           overlay_string_index is non-negative.  */
  8363                        && ((it->current.overlay_string_index >= 0
  8364                             && (it->current.overlay_string_index
  8365                                 == it->n_overlay_strings - 1))
  8366                            /* A string from display property.  */
  8367                            || it->from_disp_prop_p))
  8368                 {
  8369                   ptrdiff_t ignore;
  8370                   int next_face_id;
  8371                   bool text_from_string = false;
  8372                   /* Normally, the next buffer location is stored in
  8373                      IT->current.pos...  */
  8374                   struct text_pos pos = it->current.pos;
  8375 
  8376                   /* ...but for a string from a display property, the
  8377                      next buffer position is stored in the 'position'
  8378                      member of the iteration stack slot below the
  8379                      current one, see handle_single_display_spec.  By
  8380                      contrast, it->current.pos was not yet updated to
  8381                      point to that buffer position; that will happen
  8382                      in pop_it, after we finish displaying the current
  8383                      string.  Note that we already checked above that
  8384                      it->sp is positive, so subtracting one from it is
  8385                      safe.  */
  8386                   if (it->from_disp_prop_p)
  8387                     {
  8388                       int stackp = it->sp - 1;
  8389 
  8390                       /* Find the stack level with data from buffer.  */
  8391                       while (stackp >= 0
  8392                              && STRINGP ((it->stack + stackp)->string))
  8393                         stackp--;
  8394                       if (stackp < 0)
  8395                         {
  8396                           /* If no stack slot was found for iterating
  8397                              a buffer, we are displaying text from a
  8398                              string, most probably the mode line or
  8399                              the header line, and that string has a
  8400                              display string on some of its
  8401                              characters.  */
  8402                           text_from_string = true;
  8403                           pos = it->stack[it->sp - 1].position;
  8404                         }
  8405                       else
  8406                         pos = (it->stack + stackp)->position;
  8407                     }
  8408                   else
  8409                     INC_TEXT_POS (pos, it->multibyte_p);
  8410 
  8411                   if (text_from_string)
  8412                     {
  8413                       Lisp_Object base_string = it->stack[it->sp - 1].string;
  8414 
  8415                       if (CHARPOS (pos) >= SCHARS (base_string) - 1)
  8416                         it->end_of_box_run_p = true;
  8417                       else
  8418                         {
  8419                           next_face_id
  8420                             = face_at_string_position (it->w, base_string,
  8421                                                        CHARPOS (pos), 0,
  8422                                                        &ignore, face_id,
  8423                                                        false, 0);
  8424                           if (FACE_FROM_ID (it->f, next_face_id)->box
  8425                               == FACE_NO_BOX)
  8426                             it->end_of_box_run_p = true;
  8427                         }
  8428                     }
  8429                   else if (CHARPOS (pos) >= ZV)
  8430                     it->end_of_box_run_p = true;
  8431                   else
  8432                     {
  8433                       next_face_id =
  8434                         face_at_buffer_position (it->w, CHARPOS (pos),
  8435                                                  &ignore,
  8436                                                  CHARPOS (pos)
  8437                                                  + TEXT_PROP_DISTANCE_LIMIT,
  8438                                                  false, -1, 0);
  8439                       if (FACE_FROM_ID (it->f, next_face_id)->box
  8440                           == FACE_NO_BOX)
  8441                         it->end_of_box_run_p = true;
  8442                     }
  8443                 }
  8444             }
  8445         }
  8446       /* next_element_from_display_vector sets this flag according to
  8447          faces of the display vector glyphs, see there.  */
  8448       else if (it->method != GET_FROM_DISPLAY_VECTOR)
  8449         {
  8450           int face_id = face_after_it_pos (it);
  8451           if (face_id != it->face_id
  8452               && FACE_FROM_ID (it->f, face_id)->box == FACE_NO_BOX)
  8453             it->end_of_box_run_p = true;
  8454         }
  8455     }
  8456   /* If we reached the end of the object we've been iterating (e.g., a
  8457      display string or an overlay string), and there's something on
  8458      IT->stack, proceed with what's on the stack.  It doesn't make
  8459      sense to return false if there's unprocessed stuff on the stack,
  8460      because otherwise that stuff will never be displayed.  */
  8461   if (!success_p && it->sp > 0)
  8462     {
  8463       set_iterator_to_next (it, false);
  8464       success_p = get_next_display_element (it);
  8465     }
  8466 
  8467   /* Value is false if end of buffer or string reached.  */
  8468   return success_p;
  8469 }
  8470 
  8471 
  8472 /* Move IT to the next display element.
  8473 
  8474    RESEAT_P means if called on a newline in buffer text,
  8475    skip to the next visible line start.
  8476 
  8477    Functions get_next_display_element and set_iterator_to_next are
  8478    separate because I find this arrangement easier to handle than a
  8479    get_next_display_element function that also increments IT's
  8480    position.  The way it is we can first look at an iterator's current
  8481    display element, decide whether it fits on a line, and if it does,
  8482    increment the iterator position.  The other way around we probably
  8483    would either need a flag indicating whether the iterator has to be
  8484    incremented the next time, or we would have to implement a
  8485    decrement position function which would not be easy to write.  */
  8486 
  8487 void
  8488 set_iterator_to_next (struct it *it, bool reseat_p)
  8489 {
  8490 
  8491   if (max_redisplay_ticks > 0)
  8492     update_redisplay_ticks (1, it->w);
  8493 
  8494   switch (it->method)
  8495     {
  8496     case GET_FROM_BUFFER:
  8497       /* The current display element of IT is a character from
  8498          current_buffer.  Advance in the buffer, and maybe skip over
  8499          invisible lines that are so because of selective display.  */
  8500       if (ITERATOR_AT_END_OF_LINE_P (it) && reseat_p)
  8501         reseat_at_next_visible_line_start (it, false);
  8502       else if (it->cmp_it.id >= 0)
  8503         {
  8504           /* We are currently getting glyphs from a composition.  */
  8505           if (! it->bidi_p)
  8506             {
  8507               IT_CHARPOS (*it) += it->cmp_it.nchars;
  8508               IT_BYTEPOS (*it) += it->cmp_it.nbytes;
  8509             }
  8510           else
  8511             {
  8512               int i;
  8513 
  8514               /* Update IT's char/byte positions to point to the first
  8515                  character of the next grapheme cluster, or to the
  8516                  character visually after the current composition.  */
  8517               for (i = 0; i < it->cmp_it.nchars; i++)
  8518                 bidi_move_to_visually_next (&it->bidi_it);
  8519               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  8520               IT_CHARPOS (*it) = it->bidi_it.charpos;
  8521             }
  8522 
  8523           if ((! it->bidi_p || ! it->cmp_it.reversed_p)
  8524               && it->cmp_it.to < it->cmp_it.nglyphs)
  8525             {
  8526               /* Composition created while scanning forward.  Proceed
  8527                  to the next grapheme cluster.  */
  8528               it->cmp_it.from = it->cmp_it.to;
  8529             }
  8530           else if ((it->bidi_p && it->cmp_it.reversed_p)
  8531                    && it->cmp_it.from > 0)
  8532             {
  8533               /* Composition created while scanning backward.  Proceed
  8534                  to the previous grapheme cluster.  */
  8535               it->cmp_it.to = it->cmp_it.from;
  8536             }
  8537           else
  8538             {
  8539               /* No more grapheme clusters in this composition.
  8540                  Find the next stop position.  */
  8541               ptrdiff_t stop = it->end_charpos;
  8542 
  8543               if (it->bidi_it.scan_dir < 0)
  8544                 /* Now we are scanning backward and don't know
  8545                    where to stop.  */
  8546                 stop = -1;
  8547               composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
  8548                                             IT_BYTEPOS (*it), stop, Qnil, true);
  8549             }
  8550         }
  8551       else
  8552         {
  8553           eassert (it->len != 0);
  8554 
  8555           if (!it->bidi_p)
  8556             {
  8557               IT_BYTEPOS (*it) += it->len;
  8558               IT_CHARPOS (*it) += 1;
  8559             }
  8560           else
  8561             {
  8562               int prev_scan_dir = it->bidi_it.scan_dir;
  8563               /* If this is a new paragraph, determine its base
  8564                  direction (a.k.a. its base embedding level).  */
  8565               if (it->bidi_it.new_paragraph)
  8566                 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it,
  8567                                      false);
  8568               bidi_move_to_visually_next (&it->bidi_it);
  8569               IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  8570               IT_CHARPOS (*it) = it->bidi_it.charpos;
  8571               if (prev_scan_dir != it->bidi_it.scan_dir)
  8572                 {
  8573                   /* As the scan direction was changed, we must
  8574                      re-compute the stop position for composition.  */
  8575                   ptrdiff_t stop = it->end_charpos;
  8576                   if (it->bidi_it.scan_dir < 0)
  8577                     stop = -1;
  8578                   composition_compute_stop_pos (&it->cmp_it, IT_CHARPOS (*it),
  8579                                                 IT_BYTEPOS (*it), stop, Qnil,
  8580                                                 true);
  8581                 }
  8582             }
  8583           eassert (IT_BYTEPOS (*it) == CHAR_TO_BYTE (IT_CHARPOS (*it)));
  8584         }
  8585       break;
  8586 
  8587     case GET_FROM_C_STRING:
  8588       /* Current display element of IT is from a C string.  */
  8589       if (!it->bidi_p
  8590           /* If the string position is beyond string's end, it means
  8591              next_element_from_c_string is padding the string with
  8592              blanks, in which case we bypass the bidi iterator,
  8593              because it cannot deal with such virtual characters.  */
  8594           || IT_CHARPOS (*it) >= it->bidi_it.string.schars)
  8595         {
  8596           IT_BYTEPOS (*it) += it->len;
  8597           IT_CHARPOS (*it) += 1;
  8598         }
  8599       else
  8600         {
  8601           bidi_move_to_visually_next (&it->bidi_it);
  8602           IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  8603           IT_CHARPOS (*it) = it->bidi_it.charpos;
  8604         }
  8605       break;
  8606 
  8607     case GET_FROM_DISPLAY_VECTOR:
  8608       /* Current display element of IT is from a display table entry.
  8609          Advance in the display table definition.  Reset it to null if
  8610          end reached, and continue with characters from buffers/
  8611          strings.  */
  8612       ++it->current.dpvec_index;
  8613 
  8614       /* Restore face of the iterator to what they were before the
  8615          display vector entry (these entries may contain faces).  */
  8616       it->face_id = it->saved_face_id;
  8617 
  8618       if (it->dpvec + it->current.dpvec_index >= it->dpend)
  8619         {
  8620           bool recheck_faces = it->ellipsis_p;
  8621 
  8622           if (it->s)
  8623             it->method = GET_FROM_C_STRING;
  8624           else if (STRINGP (it->string))
  8625             it->method = GET_FROM_STRING;
  8626           else
  8627             {
  8628               it->method = GET_FROM_BUFFER;
  8629               it->object = it->w->contents;
  8630             }
  8631 
  8632           it->dpvec = NULL;
  8633           it->current.dpvec_index = -1;
  8634 
  8635           /* Skip over characters which were displayed via IT->dpvec.  */
  8636           if (it->dpvec_char_len < 0)
  8637             reseat_at_next_visible_line_start (it, true);
  8638           else if (it->dpvec_char_len > 0)
  8639             {
  8640               it->len = it->dpvec_char_len;
  8641               set_iterator_to_next (it, reseat_p);
  8642             }
  8643 
  8644           /* Maybe recheck faces after display vector.  */
  8645           if (recheck_faces)
  8646             {
  8647               if (it->method == GET_FROM_STRING)
  8648                 it->stop_charpos = IT_STRING_CHARPOS (*it);
  8649               else
  8650                 it->stop_charpos = IT_CHARPOS (*it);
  8651             }
  8652         }
  8653       break;
  8654 
  8655     case GET_FROM_STRING:
  8656       /* Current display element is a character from a Lisp string.  */
  8657       eassert (it->s == NULL && STRINGP (it->string));
  8658       /* Don't advance past string end.  These conditions are true
  8659          when set_iterator_to_next is called at the end of
  8660          get_next_display_element, in which case the Lisp string is
  8661          already exhausted, and all we want is pop the iterator
  8662          stack.  */
  8663       if (it->current.overlay_string_index >= 0)
  8664         {
  8665           /* This is an overlay string, so there's no padding with
  8666              spaces, and the number of characters in the string is
  8667              where the string ends.  */
  8668           if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
  8669             goto consider_string_end;
  8670         }
  8671       else
  8672         {
  8673           /* Not an overlay string.  There could be padding, so test
  8674              against it->end_charpos.  */
  8675           if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
  8676             goto consider_string_end;
  8677         }
  8678       if (it->cmp_it.id >= 0)
  8679         {
  8680           /* We are delivering display elements from a composition.
  8681              Update the string position past the grapheme cluster
  8682              we've just processed.  */
  8683           if (! it->bidi_p)
  8684             {
  8685               IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
  8686               IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
  8687             }
  8688           else
  8689             {
  8690               int i;
  8691 
  8692               for (i = 0; i < it->cmp_it.nchars; i++)
  8693                 bidi_move_to_visually_next (&it->bidi_it);
  8694               IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  8695               IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  8696             }
  8697 
  8698           /* Did we exhaust all the grapheme clusters of this
  8699              composition?  */
  8700           if ((! it->bidi_p || ! it->cmp_it.reversed_p)
  8701               && (it->cmp_it.to < it->cmp_it.nglyphs))
  8702             {
  8703               /* Not all the grapheme clusters were processed yet;
  8704                  advance to the next cluster.  */
  8705               it->cmp_it.from = it->cmp_it.to;
  8706             }
  8707           else if ((it->bidi_p && it->cmp_it.reversed_p)
  8708                    && it->cmp_it.from > 0)
  8709             {
  8710               /* Likewise: advance to the next cluster, but going in
  8711                  the reverse direction.  */
  8712               it->cmp_it.to = it->cmp_it.from;
  8713             }
  8714           else
  8715             {
  8716               /* This composition was fully processed; find the next
  8717                  candidate place for checking for composed
  8718                  characters.  */
  8719               /* Always limit string searches to the string length;
  8720                  any padding spaces are not part of the string, and
  8721                  there cannot be any compositions in that padding.  */
  8722               ptrdiff_t stop = SCHARS (it->string);
  8723 
  8724               if (it->bidi_p && it->bidi_it.scan_dir < 0)
  8725                 stop = -1;
  8726               else if (it->end_charpos < stop)
  8727                 {
  8728                   /* Cf. PRECISION in reseat_to_string: we might be
  8729                      limited in how many of the string characters we
  8730                      need to deliver.  */
  8731                   stop = it->end_charpos;
  8732                 }
  8733               composition_compute_stop_pos (&it->cmp_it,
  8734                                             IT_STRING_CHARPOS (*it),
  8735                                             IT_STRING_BYTEPOS (*it), stop,
  8736                                             it->string, true);
  8737             }
  8738         }
  8739       else
  8740         {
  8741           if (!it->bidi_p
  8742               /* If the string position is beyond string's end, it
  8743                  means next_element_from_string is padding the string
  8744                  with blanks, in which case we bypass the bidi
  8745                  iterator, because it cannot deal with such virtual
  8746                  characters.  */
  8747               || IT_STRING_CHARPOS (*it) >= it->bidi_it.string.schars)
  8748             {
  8749               IT_STRING_BYTEPOS (*it) += it->len;
  8750               IT_STRING_CHARPOS (*it) += 1;
  8751             }
  8752           else
  8753             {
  8754               int prev_scan_dir = it->bidi_it.scan_dir;
  8755 
  8756               bidi_move_to_visually_next (&it->bidi_it);
  8757               IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  8758               IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  8759               /* If the scan direction changes, we may need to update
  8760                  the place where to check for composed characters.  */
  8761               if (prev_scan_dir != it->bidi_it.scan_dir)
  8762                 {
  8763                   ptrdiff_t stop = SCHARS (it->string);
  8764 
  8765                   if (it->bidi_it.scan_dir < 0)
  8766                     stop = -1;
  8767                   else if (it->end_charpos < stop)
  8768                     stop = it->end_charpos;
  8769 
  8770                   composition_compute_stop_pos (&it->cmp_it,
  8771                                                 IT_STRING_CHARPOS (*it),
  8772                                                 IT_STRING_BYTEPOS (*it), stop,
  8773                                                 it->string, true);
  8774                 }
  8775             }
  8776         }
  8777 
  8778     consider_string_end:
  8779 
  8780       if (it->current.overlay_string_index >= 0)
  8781         {
  8782           /* IT->string is an overlay string.  Advance to the
  8783              next, if there is one.  */
  8784           if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
  8785             {
  8786               it->ellipsis_p = false;
  8787               next_overlay_string (it);
  8788               if (it->ellipsis_p)
  8789                 setup_for_ellipsis (it, 0);
  8790             }
  8791         }
  8792       else
  8793         {
  8794           /* IT->string is not an overlay string.  If we reached
  8795              its end, and there is something on IT->stack, proceed
  8796              with what is on the stack.  This can be either another
  8797              string, this time an overlay string, or a buffer.  */
  8798           if (IT_STRING_CHARPOS (*it) == SCHARS (it->string)
  8799               && it->sp > 0)
  8800             {
  8801               pop_it (it);
  8802               if (it->method == GET_FROM_STRING)
  8803                 goto consider_string_end;
  8804             }
  8805         }
  8806       break;
  8807 
  8808     case GET_FROM_IMAGE:
  8809     case GET_FROM_STRETCH:
  8810     case GET_FROM_XWIDGET:
  8811 
  8812       /* The position etc with which we have to proceed are on
  8813          the stack.  The position may be at the end of a string,
  8814          if the `display' property takes up the whole string.  */
  8815       eassert (it->sp > 0);
  8816       pop_it (it);
  8817       if (it->method == GET_FROM_STRING)
  8818         goto consider_string_end;
  8819       break;
  8820 
  8821     default:
  8822       /* There are no other methods defined, so this should be a bug.  */
  8823       emacs_abort ();
  8824     }
  8825 
  8826   eassert (it->method != GET_FROM_STRING
  8827            || (STRINGP (it->string)
  8828                && IT_STRING_CHARPOS (*it) >= 0));
  8829 }
  8830 
  8831 /* Load IT's display element fields with information about the next
  8832    display element which comes from a display table entry or from the
  8833    result of translating a control character to one of the forms `^C'
  8834    or `\003'.
  8835 
  8836    IT->dpvec holds the glyphs to return as characters.
  8837    IT->saved_face_id holds the face id before the display vector--it
  8838    is restored into IT->face_id in set_iterator_to_next.  */
  8839 
  8840 static bool
  8841 next_element_from_display_vector (struct it *it)
  8842 {
  8843   Lisp_Object gc;
  8844   int prev_face_id = it->face_id;
  8845   int next_face_id;
  8846 
  8847   /* Precondition.  */
  8848   eassert (it->dpvec && it->current.dpvec_index >= 0);
  8849 
  8850   it->face_id = it->saved_face_id;
  8851 
  8852   /* KFS: This code used to check ip->dpvec[0] instead of the current element.
  8853      That seemed totally bogus - so I changed it...  */
  8854   if (it->dpend - it->dpvec > 0 /* empty dpvec[] is invalid */
  8855       && (gc = it->dpvec[it->current.dpvec_index], GLYPH_CODE_P (gc)))
  8856     {
  8857       struct face *this_face, *prev_face, *next_face;
  8858 
  8859       it->c = GLYPH_CODE_CHAR (gc);
  8860       it->len = CHAR_BYTES (it->c);
  8861 
  8862       /* The entry may contain a face id to use.  Such a face id is
  8863          the id of a Lisp face, not a realized face.  A face id of
  8864          zero means no face is specified.  */
  8865       if (it->dpvec_face_id >= 0)
  8866         it->face_id = it->dpvec_face_id;
  8867       else
  8868         {
  8869           int lface_id = GLYPH_CODE_FACE (gc);
  8870           if (lface_id > 0)
  8871             it->face_id = merge_faces (it->w, Qt, lface_id,
  8872                                        it->saved_face_id);
  8873         }
  8874 
  8875       /* Glyphs in the display vector could have the box face, so we
  8876          need to set the related flags in the iterator, as
  8877          appropriate.  */
  8878       this_face = FACE_FROM_ID_OR_NULL (it->f, it->face_id);
  8879       prev_face = FACE_FROM_ID_OR_NULL (it->f, prev_face_id);
  8880 
  8881       /* Is this character the first character of a box-face run?  */
  8882       it->start_of_box_run_p = (this_face && this_face->box != FACE_NO_BOX
  8883                                 && (!prev_face
  8884                                     || prev_face->box == FACE_NO_BOX));
  8885 
  8886       /* For the last character of the box-face run, we need to look
  8887          either at the next glyph from the display vector, or at the
  8888          face we saw before the display vector.  */
  8889       next_face_id = it->saved_face_id;
  8890       if (it->current.dpvec_index < it->dpend - it->dpvec - 1)
  8891         {
  8892           if (it->dpvec_face_id >= 0)
  8893             next_face_id = it->dpvec_face_id;
  8894           else
  8895             {
  8896               Lisp_Object gc = it->dpvec[it->current.dpvec_index + 1];
  8897               int lface_id = GLYPH_CODE_P (gc) ? GLYPH_CODE_FACE (gc) : 0;
  8898 
  8899               if (lface_id > 0)
  8900                 next_face_id = merge_faces (it->w, Qt, lface_id,
  8901                                             it->saved_face_id);
  8902             }
  8903         }
  8904       next_face = FACE_FROM_ID_OR_NULL (it->f, next_face_id);
  8905       if (this_face && this_face->box != FACE_NO_BOX
  8906           && (!next_face || next_face->box == FACE_NO_BOX))
  8907         it->end_of_box_run_p = true;
  8908       it->face_box_p = this_face && this_face->box != FACE_NO_BOX;
  8909     }
  8910   else
  8911     /* Display table entry is invalid.  Return a space.  */
  8912     it->c = ' ', it->len = 1;
  8913 
  8914   /* Don't change position and object of the iterator here.  They are
  8915      still the values of the character that had this display table
  8916      entry or was translated, and that's what we want.  */
  8917   it->what = IT_CHARACTER;
  8918   return true;
  8919 }
  8920 
  8921 /* Get the first element of string/buffer in the visual order, after
  8922    being reseated to a new position in a string or a buffer.  */
  8923 static void
  8924 get_visually_first_element (struct it *it)
  8925 {
  8926   bool string_p = STRINGP (it->string) || it->s;
  8927   ptrdiff_t eob = (string_p ? it->bidi_it.string.schars : ZV);
  8928   ptrdiff_t bob;
  8929   ptrdiff_t obegv = BEGV;
  8930 
  8931   SET_WITH_NARROWED_BEGV (it, bob,
  8932                           string_p ? 0 :
  8933                           IT_CHARPOS (*it) < BEGV ? obegv : BEGV,
  8934                           it->medium_narrowing_begv);
  8935 
  8936   if (STRINGP (it->string))
  8937     {
  8938       it->bidi_it.charpos = IT_STRING_CHARPOS (*it);
  8939       it->bidi_it.bytepos = IT_STRING_BYTEPOS (*it);
  8940     }
  8941   else
  8942     {
  8943       it->bidi_it.charpos = IT_CHARPOS (*it);
  8944       it->bidi_it.bytepos = IT_BYTEPOS (*it);
  8945     }
  8946 
  8947   if (it->bidi_it.charpos == eob)
  8948     {
  8949       /* Nothing to do, but reset the FIRST_ELT flag, like
  8950          bidi_paragraph_init does, because we are not going to
  8951          call it.  */
  8952       it->bidi_it.first_elt = false;
  8953     }
  8954   else if (it->bidi_it.charpos == bob
  8955            || (!string_p
  8956                && (FETCH_BYTE (it->bidi_it.bytepos - 1) == '\n'
  8957                    || FETCH_BYTE (it->bidi_it.bytepos) == '\n')))
  8958     {
  8959       /* If we are at the beginning of a line/string, we can produce
  8960          the next element right away.  */
  8961       bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, true);
  8962       bidi_move_to_visually_next (&it->bidi_it);
  8963     }
  8964   else
  8965     {
  8966       ptrdiff_t orig_bytepos = it->bidi_it.bytepos;
  8967 
  8968       /* We need to prime the bidi iterator starting at the line's or
  8969          string's beginning, before we will be able to produce the
  8970          next element.  */
  8971       if (string_p)
  8972         it->bidi_it.charpos = it->bidi_it.bytepos = 0;
  8973       else
  8974         SET_WITH_NARROWED_BEGV (it, it->bidi_it.charpos,
  8975                                 find_newline_no_quit (IT_CHARPOS (*it),
  8976                                                       IT_BYTEPOS (*it), -1,
  8977                                                       &it->bidi_it.bytepos),
  8978                                 it->medium_narrowing_begv);
  8979       bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it, true);
  8980       do
  8981         {
  8982           /* Now return to buffer/string position where we were asked
  8983              to get the next display element, and produce that.  */
  8984           bidi_move_to_visually_next (&it->bidi_it);
  8985         }
  8986       while (it->bidi_it.bytepos != orig_bytepos
  8987              && it->bidi_it.charpos < eob);
  8988     }
  8989 
  8990   /*  Adjust IT's position information to where we ended up.  */
  8991   if (STRINGP (it->string))
  8992     {
  8993       IT_STRING_CHARPOS (*it) = it->bidi_it.charpos;
  8994       IT_STRING_BYTEPOS (*it) = it->bidi_it.bytepos;
  8995     }
  8996   else
  8997     {
  8998       IT_CHARPOS (*it) = it->bidi_it.charpos;
  8999       IT_BYTEPOS (*it) = it->bidi_it.bytepos;
  9000     }
  9001 
  9002   if (STRINGP (it->string) || !it->s)
  9003     {
  9004       ptrdiff_t stop, charpos, bytepos;
  9005 
  9006       if (STRINGP (it->string))
  9007         {
  9008           eassert (!it->s);
  9009           stop = SCHARS (it->string);
  9010           if (stop > it->end_charpos)
  9011             stop = it->end_charpos;
  9012           charpos = IT_STRING_CHARPOS (*it);
  9013           bytepos = IT_STRING_BYTEPOS (*it);
  9014         }
  9015       else
  9016         {
  9017           stop = it->end_charpos;
  9018           charpos = IT_CHARPOS (*it);
  9019           bytepos = IT_BYTEPOS (*it);
  9020         }
  9021       if (it->bidi_it.scan_dir < 0)
  9022         stop = -1;
  9023       composition_compute_stop_pos (&it->cmp_it, charpos, bytepos, stop,
  9024                                     it->string, true);
  9025     }
  9026 }
  9027 
  9028 /* Load IT with the next display element from Lisp string IT->string.
  9029    IT->current.string_pos is the current position within the string.
  9030    If IT->current.overlay_string_index >= 0, the Lisp string is an
  9031    overlay string.  */
  9032 
  9033 static bool
  9034 next_element_from_string (struct it *it)
  9035 {
  9036   struct text_pos position;
  9037 
  9038   eassert (STRINGP (it->string));
  9039   eassert (!it->bidi_p || EQ (it->string, it->bidi_it.string.lstring));
  9040   eassert (IT_STRING_CHARPOS (*it) >= 0);
  9041   position = it->current.string_pos;
  9042 
  9043   /* With bidi reordering, the character to display might not be the
  9044      character at IT_STRING_CHARPOS.  BIDI_IT.FIRST_ELT means
  9045      that we were reseat()ed to a new string, whose paragraph
  9046      direction is not known.  */
  9047   if (it->bidi_p && it->bidi_it.first_elt)
  9048     {
  9049       get_visually_first_element (it);
  9050       SET_TEXT_POS (position, IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it));
  9051     }
  9052 
  9053   /* Time to check for invisible text?  */
  9054   if (IT_STRING_CHARPOS (*it) < it->end_charpos)
  9055     {
  9056       if (IT_STRING_CHARPOS (*it) >= it->stop_charpos)
  9057         {
  9058           if (!(!it->bidi_p
  9059                 || BIDI_AT_BASE_LEVEL (it->bidi_it)
  9060                 || IT_STRING_CHARPOS (*it) == it->stop_charpos))
  9061             {
  9062               /* With bidi non-linear iteration, we could find
  9063                  ourselves far beyond the last computed stop_charpos,
  9064                  with several other stop positions in between that we
  9065                  missed.  Scan them all now, in buffer's logical
  9066                  order, until we find and handle the last stop_charpos
  9067                  that precedes our current position.  */
  9068               handle_stop_backwards (it, it->stop_charpos);
  9069               return GET_NEXT_DISPLAY_ELEMENT (it);
  9070             }
  9071           else
  9072             {
  9073               if (it->bidi_p)
  9074                 {
  9075                   /* Take note of the stop position we just moved
  9076                      across, for when we will move back across it.  */
  9077                   it->prev_stop = it->stop_charpos;
  9078                   /* If we are at base paragraph embedding level, take
  9079                      note of the last stop position seen at this
  9080                      level.  */
  9081                   if (BIDI_AT_BASE_LEVEL (it->bidi_it))
  9082                     it->base_level_stop = it->stop_charpos;
  9083                 }
  9084               handle_stop (it);
  9085 
  9086               /* Since a handler may have changed IT->method, we must
  9087                  recurse here.  */
  9088               return GET_NEXT_DISPLAY_ELEMENT (it);
  9089             }
  9090         }
  9091       else if (it->bidi_p
  9092                /* If we are before prev_stop, we may have overstepped
  9093                   on our way backwards a stop_pos, and if so, we need
  9094                   to handle that stop_pos.  */
  9095                && IT_STRING_CHARPOS (*it) < it->prev_stop
  9096                /* We can sometimes back up for reasons that have nothing
  9097                   to do with bidi reordering.  E.g., compositions.  The
  9098                   code below is only needed when we are above the base
  9099                   embedding level, so test for that explicitly.  */
  9100                && !BIDI_AT_BASE_LEVEL (it->bidi_it))
  9101         {
  9102           /* If we lost track of base_level_stop, we have no better
  9103              place for handle_stop_backwards to start from than string
  9104              beginning.  This happens, e.g., when we were reseated to
  9105              the previous screenful of text by vertical-motion.  */
  9106           if (it->base_level_stop <= 0
  9107               || IT_STRING_CHARPOS (*it) < it->base_level_stop)
  9108             it->base_level_stop = 0;
  9109           handle_stop_backwards (it, it->base_level_stop);
  9110           return GET_NEXT_DISPLAY_ELEMENT (it);
  9111         }
  9112     }
  9113 
  9114   if (it->current.overlay_string_index >= 0)
  9115     {
  9116       /* Get the next character from an overlay string.  In overlay
  9117          strings, there is no field width or padding with spaces to
  9118          do.  */
  9119       if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
  9120         {
  9121           it->what = IT_EOB;
  9122           return false;
  9123         }
  9124       else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
  9125                                 IT_STRING_BYTEPOS (*it),
  9126                                 it->bidi_it.scan_dir < 0
  9127                                 ? -1
  9128                                 : SCHARS (it->string))
  9129                && next_element_from_composition (it))
  9130         {
  9131           return true;
  9132         }
  9133       else if (STRING_MULTIBYTE (it->string))
  9134         {
  9135           const unsigned char *s = (SDATA (it->string)
  9136                                     + IT_STRING_BYTEPOS (*it));
  9137           it->c = check_char_and_length (s, &it->len);
  9138         }
  9139       else
  9140         {
  9141           it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
  9142           it->len = 1;
  9143         }
  9144     }
  9145   else
  9146     {
  9147       /* Get the next character from a Lisp string that is not an
  9148          overlay string.  Such strings come from the mode line, for
  9149          example.  We may have to pad with spaces, or truncate the
  9150          string.  See also next_element_from_c_string.  */
  9151       if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
  9152         {
  9153           it->what = IT_EOB;
  9154           return false;
  9155         }
  9156       else if (IT_STRING_CHARPOS (*it) >= it->string_nchars)
  9157         {
  9158           /* Pad with spaces.  */
  9159           it->c = ' ', it->len = 1;
  9160           CHARPOS (position) = BYTEPOS (position) = -1;
  9161         }
  9162       else if (CHAR_COMPOSED_P (it, IT_STRING_CHARPOS (*it),
  9163                                 IT_STRING_BYTEPOS (*it),
  9164                                 it->bidi_it.scan_dir < 0
  9165                                 ? -1
  9166                                 : it->string_nchars)
  9167                && next_element_from_composition (it))
  9168         {
  9169           return true;
  9170         }
  9171       else if (STRING_MULTIBYTE (it->string))
  9172         {
  9173           const unsigned char *s = (SDATA (it->string)
  9174                                     + IT_STRING_BYTEPOS (*it));
  9175           it->c = check_char_and_length (s, &it->len);
  9176         }
  9177       else
  9178         {
  9179           it->c = SREF (it->string, IT_STRING_BYTEPOS (*it));
  9180           it->len = 1;
  9181         }
  9182     }
  9183 
  9184   /* Record what we have and where it came from.  */
  9185   it->what = IT_CHARACTER;
  9186   it->object = it->string;
  9187   it->position = position;
  9188   return true;
  9189 }
  9190 
  9191 
  9192 /* Load IT with next display element from C string IT->s.
  9193    IT->string_nchars is the maximum number of characters to return
  9194    from the string.  IT->end_charpos may be greater than
  9195    IT->string_nchars when this function is called, in which case we
  9196    may have to return padding spaces.  Value is false if end of string
  9197    reached, including padding spaces.  */
  9198 
  9199 static bool
  9200 next_element_from_c_string (struct it *it)
  9201 {
  9202   bool success_p = true;
  9203 
  9204   eassert (it->s);
  9205   eassert (!it->bidi_p || it->s == it->bidi_it.string.s);
  9206   it->what = IT_CHARACTER;
  9207   BYTEPOS (it->position) = CHARPOS (it->position) = 0;
  9208   it->object = make_fixnum (0);
  9209 
  9210   /* With bidi reordering, the character to display might not be the
  9211      character at IT_CHARPOS.  BIDI_IT.FIRST_ELT means that
  9212      we were reseated to a new string, whose paragraph direction is
  9213      not known.  */
  9214   if (it->bidi_p && it->bidi_it.first_elt)
  9215     get_visually_first_element (it);
  9216 
  9217   /* IT's position can be greater than IT->string_nchars in case a
  9218      field width or precision has been specified when the iterator was
  9219      initialized.  */
  9220   if (IT_CHARPOS (*it) >= it->end_charpos)
  9221     {
  9222       /* End of the game.  */
  9223       it->what = IT_EOB;
  9224       success_p = false;
  9225     }
  9226   else if (IT_CHARPOS (*it) >= it->string_nchars)
  9227     {
  9228       /* Pad with spaces.  */
  9229       it->c = ' ', it->len = 1;
  9230       BYTEPOS (it->position) = CHARPOS (it->position) = -1;
  9231     }
  9232   else if (it->multibyte_p)
  9233     it->c = check_char_and_length (it->s + IT_BYTEPOS (*it), &it->len);
  9234   else
  9235     it->c = it->s[IT_BYTEPOS (*it)], it->len = 1;
  9236 
  9237   return success_p;
  9238 }
  9239 
  9240 
  9241 /* Set up IT to return characters from an ellipsis, if appropriate.
  9242    The definition of the ellipsis glyphs may come from a display table
  9243    entry.  This function fills IT with the first glyph from the
  9244    ellipsis if an ellipsis is to be displayed.  */
  9245 
  9246 static bool
  9247 next_element_from_ellipsis (struct it *it)
  9248 {
  9249   if (it->selective_display_ellipsis_p)
  9250     setup_for_ellipsis (it, it->len);
  9251   else
  9252     {
  9253       /* The face at the current position may be different from the
  9254          face we find after the invisible text.  Remember what it
  9255          was in IT->saved_face_id, and signal that it's there by
  9256          setting face_before_selective_p.  */
  9257       it->saved_face_id = it->face_id;
  9258       it->method = GET_FROM_BUFFER;
  9259       it->object = it->w->contents;
  9260       reseat_at_next_visible_line_start (it, true);
  9261       it->face_before_selective_p = true;
  9262     }
  9263 
  9264   return GET_NEXT_DISPLAY_ELEMENT (it);
  9265 }
  9266 
  9267 
  9268 /* Deliver an image display element.  The iterator IT is already
  9269    filled with image information (done in handle_display_prop).  Value
  9270    is always true.  */
  9271 
  9272 
  9273 static bool
  9274 next_element_from_image (struct it *it)
  9275 {
  9276   it->what = IT_IMAGE;
  9277   return true;
  9278 }
  9279 
  9280 static bool
  9281 next_element_from_xwidget (struct it *it)
  9282 {
  9283   it->what = IT_XWIDGET;
  9284   return true;
  9285 }
  9286 
  9287 
  9288 /* Fill iterator IT with next display element from a stretch glyph
  9289    property.  IT->object is the value of the text property.  Value is
  9290    always true.  */
  9291 
  9292 static bool
  9293 next_element_from_stretch (struct it *it)
  9294 {
  9295   it->what = IT_STRETCH;
  9296   return true;
  9297 }
  9298 
  9299 /* Scan backwards from IT's current position until we find a stop
  9300    position, or until BEGV.  This is called when we find ourself
  9301    before both the last known prev_stop and base_level_stop while
  9302    reordering bidirectional text.  */
  9303 
  9304 static void
  9305 compute_stop_pos_backwards (struct it *it)
  9306 {
  9307   const int SCAN_BACK_LIMIT = 1000;
  9308   struct text_pos pos;
  9309   struct display_pos save_current = it->current;
  9310   struct text_pos save_position = it->position;
  9311   ptrdiff_t charpos = IT_CHARPOS (*it);
  9312   ptrdiff_t where_we_are = charpos;
  9313   ptrdiff_t save_stop_pos = it->stop_charpos;
  9314   ptrdiff_t save_end_pos = it->end_charpos;
  9315 
  9316   eassert (NILP (it->string) && !it->s);
  9317   eassert (it->bidi_p);
  9318   it->bidi_p = false;
  9319   do
  9320     {
  9321       it->end_charpos = min (charpos + 1, ZV);
  9322       charpos = max (charpos - SCAN_BACK_LIMIT, BEGV);
  9323       SET_TEXT_POS (pos, charpos, CHAR_TO_BYTE (charpos));
  9324       reseat_1 (it, pos, false);
  9325       compute_stop_pos (it);
  9326       /* We must advance forward, right?  */
  9327       if (it->stop_charpos <= charpos)
  9328         emacs_abort ();
  9329     }
  9330   while (charpos > BEGV && it->stop_charpos >= it->end_charpos);
  9331 
  9332   if (it->stop_charpos <= where_we_are)
  9333     it->prev_stop = it->stop_charpos;
  9334   else
  9335     it->prev_stop = BEGV;
  9336   it->bidi_p = true;
  9337   it->current = save_current;
  9338   it->position = save_position;
  9339   it->stop_charpos = save_stop_pos;
  9340   it->end_charpos = save_end_pos;
  9341 }
  9342 
  9343 /* Scan forward from CHARPOS in the current buffer/string, until we
  9344    find a stop position > current IT's position.  Then handle the stop
  9345    position before that.  This is called when we bump into a stop
  9346    position while reordering bidirectional text.  CHARPOS should be
  9347    the last previously processed stop_pos (or BEGV/0, if none were
  9348    processed yet) whose position is less than IT's current
  9349    position.  */
  9350 
  9351 static void
  9352 handle_stop_backwards (struct it *it, ptrdiff_t charpos)
  9353 {
  9354   bool bufp = !STRINGP (it->string);
  9355   ptrdiff_t where_we_are = (bufp ? IT_CHARPOS (*it) : IT_STRING_CHARPOS (*it));
  9356   struct display_pos save_current = it->current;
  9357   struct text_pos save_position = it->position;
  9358   struct composition_it save_cmp_it = it->cmp_it;
  9359   struct text_pos pos1;
  9360   ptrdiff_t next_stop;
  9361 
  9362   /* Scan in strict logical order.  */
  9363   eassert (it->bidi_p);
  9364   it->bidi_p = false;
  9365   do
  9366     {
  9367       it->prev_stop = charpos;
  9368       if (bufp)
  9369         {
  9370           SET_TEXT_POS (pos1, charpos, CHAR_TO_BYTE (charpos));
  9371           reseat_1 (it, pos1, false);
  9372         }
  9373       else
  9374         it->current.string_pos = string_pos (charpos, it->string);
  9375       compute_stop_pos (it);
  9376       /* We must advance forward, right?  */
  9377       if (it->stop_charpos <= it->prev_stop)
  9378         emacs_abort ();
  9379       charpos = it->stop_charpos;
  9380     }
  9381   while (charpos <= where_we_are);
  9382 
  9383   it->bidi_p = true;
  9384   it->current = save_current;
  9385   it->position = save_position;
  9386   it->cmp_it = save_cmp_it;
  9387   next_stop = it->stop_charpos;
  9388   it->stop_charpos = it->prev_stop;
  9389   handle_stop (it);
  9390   it->stop_charpos = next_stop;
  9391 }
  9392 
  9393 /* Load IT with the next display element from current_buffer.  Value
  9394    is false if end of buffer reached.  IT->stop_charpos is the next
  9395    position at which to stop and check for text properties or buffer
  9396    end.  */
  9397 
  9398 static bool
  9399 next_element_from_buffer (struct it *it)
  9400 {
  9401   bool success_p = true;
  9402 
  9403   eassert (IT_CHARPOS (*it) >= BEGV);
  9404   eassert (NILP (it->string) && !it->s);
  9405   eassert (!it->bidi_p
  9406            || (NILP (it->bidi_it.string.lstring)
  9407                && it->bidi_it.string.s == NULL));
  9408 
  9409   /* With bidi reordering, the character to display might not be the
  9410      character at IT_CHARPOS.  BIDI_IT.FIRST_ELT means that
  9411      we were reseat()ed to a new buffer position, which is potentially
  9412      a different paragraph.  */
  9413   if (it->bidi_p && it->bidi_it.first_elt)
  9414     {
  9415       get_visually_first_element (it);
  9416       SET_TEXT_POS (it->position, IT_CHARPOS (*it), IT_BYTEPOS (*it));
  9417     }
  9418 
  9419   if (IT_CHARPOS (*it) >= it->stop_charpos)
  9420     {
  9421       if (IT_CHARPOS (*it) >= it->end_charpos)
  9422         {
  9423           bool overlay_strings_follow_p;
  9424 
  9425           /* End of the game, except when overlay strings follow that
  9426              haven't been returned yet.  */
  9427           if (it->overlay_strings_at_end_processed_p)
  9428             overlay_strings_follow_p = false;
  9429           else
  9430             {
  9431               it->overlay_strings_at_end_processed_p = true;
  9432               overlay_strings_follow_p = get_overlay_strings (it, 0);
  9433             }
  9434 
  9435           if (overlay_strings_follow_p)
  9436             success_p = GET_NEXT_DISPLAY_ELEMENT (it);
  9437           else
  9438             {
  9439               it->what = IT_EOB;
  9440               it->position = it->current.pos;
  9441               success_p = false;
  9442             }
  9443         }
  9444       else if (!(!it->bidi_p
  9445                  || BIDI_AT_BASE_LEVEL (it->bidi_it)
  9446                  || IT_CHARPOS (*it) == it->stop_charpos))
  9447         {
  9448           /* With bidi non-linear iteration, we could find ourselves
  9449              far beyond the last computed stop_charpos, with several
  9450              other stop positions in between that we missed.  Scan
  9451              them all now, in buffer's logical order, until we find
  9452              and handle the last stop_charpos that precedes our
  9453              current position.  */
  9454           handle_stop_backwards (it, it->stop_charpos);
  9455           it->ignore_overlay_strings_at_pos_p = false;
  9456           return GET_NEXT_DISPLAY_ELEMENT (it);
  9457         }
  9458       else
  9459         {
  9460           if (it->bidi_p)
  9461             {
  9462               /* Take note of the stop position we just moved across,
  9463                  for when we will move back across it.  */
  9464               it->prev_stop = it->stop_charpos;
  9465               /* If we are at base paragraph embedding level, take
  9466                  note of the last stop position seen at this
  9467                  level.  */
  9468               if (BIDI_AT_BASE_LEVEL (it->bidi_it))
  9469                 it->base_level_stop = it->stop_charpos;
  9470             }
  9471           handle_stop (it);
  9472           it->ignore_overlay_strings_at_pos_p = false;
  9473           return GET_NEXT_DISPLAY_ELEMENT (it);
  9474         }
  9475     }
  9476   else if (it->bidi_p
  9477            /* If we are before prev_stop, we may have overstepped on
  9478               our way backwards a stop_pos, and if so, we need to
  9479               handle that stop_pos.  */
  9480            && IT_CHARPOS (*it) < it->prev_stop
  9481            /* We can sometimes back up for reasons that have nothing
  9482               to do with bidi reordering.  E.g., compositions.  The
  9483               code below is only needed when we are above the base
  9484               embedding level, so test for that explicitly.  */
  9485            && !BIDI_AT_BASE_LEVEL (it->bidi_it))
  9486     {
  9487       if (it->base_level_stop <= 0
  9488           || IT_CHARPOS (*it) < it->base_level_stop)
  9489         {
  9490           /* If we lost track of base_level_stop, we need to find
  9491              prev_stop by looking backwards.  This happens, e.g., when
  9492              we were reseated to the previous screenful of text by
  9493              vertical-motion.  */
  9494           it->base_level_stop = BEGV;
  9495           compute_stop_pos_backwards (it);
  9496           handle_stop_backwards (it, it->prev_stop);
  9497         }
  9498       else
  9499         handle_stop_backwards (it, it->base_level_stop);
  9500       it->ignore_overlay_strings_at_pos_p = false;
  9501       return GET_NEXT_DISPLAY_ELEMENT (it);
  9502     }
  9503   else
  9504     {
  9505       /* No face changes, overlays etc. in sight, so just return a
  9506          character from current_buffer.  */
  9507       unsigned char *p;
  9508       ptrdiff_t stop;
  9509 
  9510       /* We moved to the next buffer position, so any info about
  9511          previously seen overlays is no longer valid.  */
  9512       it->ignore_overlay_strings_at_pos_p = false;
  9513 
  9514       if (composition_break_at_point
  9515           && !NILP (BVAR (current_buffer, enable_multibyte_characters))
  9516           && !NILP (Vauto_composition_mode))
  9517         {
  9518           /* Limit search for composable characters to point's position.  */
  9519           if (it->bidi_it.scan_dir < 0)
  9520             stop = (PT <= IT_CHARPOS (*it)) ? PT : -1;
  9521           else
  9522             stop = (IT_CHARPOS (*it) < PT
  9523                     && PT < it->end_charpos) ? PT : it->end_charpos;
  9524         }
  9525       else
  9526         stop = it->bidi_it.scan_dir < 0 ? -1 : it->end_charpos;
  9527       if (CHAR_COMPOSED_P (it, IT_CHARPOS (*it), IT_BYTEPOS (*it),
  9528                            stop)
  9529           && next_element_from_composition (it))
  9530         {
  9531           return true;
  9532         }
  9533 
  9534       /* Get the next character, maybe multibyte.  */
  9535       p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
  9536       if (it->multibyte_p && !ASCII_CHAR_P (*p))
  9537         it->c = string_char_and_length (p, &it->len);
  9538       else
  9539         it->c = *p, it->len = 1;
  9540 
  9541       /* Record what we have and where it came from.  */
  9542       it->what = IT_CHARACTER;
  9543       it->object = it->w->contents;
  9544       it->position = it->current.pos;
  9545 
  9546       /* Normally we return the character found above, except when we
  9547          really want to return an ellipsis for selective display.  */
  9548       if (it->selective)
  9549         {
  9550           if (it->c == '\n')
  9551             {
  9552               /* A value of selective > 0 means hide lines indented more
  9553                  than that number of columns.  */
  9554               if (it->selective > 0
  9555                   && IT_CHARPOS (*it) + 1 < ZV
  9556                   && indented_beyond_p (IT_CHARPOS (*it) + 1,
  9557                                         IT_BYTEPOS (*it) + 1,
  9558                                         it->selective))
  9559                 {
  9560                   success_p = next_element_from_ellipsis (it);
  9561                   it->dpvec_char_len = -1;
  9562                 }
  9563             }
  9564           else if (it->c == '\r' && it->selective == -1)
  9565             {
  9566               /* A value of selective == -1 means that everything from the
  9567                  CR to the end of the line is invisible, with maybe an
  9568                  ellipsis displayed for it.  */
  9569               success_p = next_element_from_ellipsis (it);
  9570               it->dpvec_char_len = -1;
  9571             }
  9572         }
  9573     }
  9574 
  9575   /* Value is false if end of buffer reached.  */
  9576   eassert (!success_p || it->what != IT_CHARACTER || it->len > 0);
  9577   return success_p;
  9578 }
  9579 
  9580 
  9581 /* Deliver a composition display element.  Unlike the other
  9582    next_element_from_XXX, this function is not registered in the array
  9583    get_next_element[].  It is called from next_element_from_buffer and
  9584    next_element_from_string when necessary.  */
  9585 
  9586 static bool
  9587 next_element_from_composition (struct it *it)
  9588 {
  9589   it->what = IT_COMPOSITION;
  9590   it->len = it->cmp_it.nbytes;
  9591   if (STRINGP (it->string))
  9592     {
  9593       if (it->c < 0)
  9594         {
  9595           IT_STRING_CHARPOS (*it) += it->cmp_it.nchars;
  9596           IT_STRING_BYTEPOS (*it) += it->cmp_it.nbytes;
  9597           return false;
  9598         }
  9599       it->position = it->current.string_pos;
  9600       it->object = it->string;
  9601       it->c = composition_update_it (&it->cmp_it, IT_STRING_CHARPOS (*it),
  9602                                      IT_STRING_BYTEPOS (*it), it->string);
  9603     }
  9604   else
  9605     {
  9606       if (it->c < 0)
  9607         {
  9608           IT_CHARPOS (*it) += it->cmp_it.nchars;
  9609           IT_BYTEPOS (*it) += it->cmp_it.nbytes;
  9610           if (it->bidi_p)
  9611             {
  9612               if (it->bidi_it.new_paragraph)
  9613                 bidi_paragraph_init (it->paragraph_embedding, &it->bidi_it,
  9614                                      false);
  9615               /* Resync the bidi iterator with IT's new position.
  9616                  FIXME: this doesn't support bidirectional text.  */
  9617               while (it->bidi_it.charpos < IT_CHARPOS (*it))
  9618                 bidi_move_to_visually_next (&it->bidi_it);
  9619             }
  9620           return false;
  9621         }
  9622       it->position = it->current.pos;
  9623       it->object = it->w->contents;
  9624       it->c = composition_update_it (&it->cmp_it, IT_CHARPOS (*it),
  9625                                      IT_BYTEPOS (*it), Qnil);
  9626     }
  9627   return true;
  9628 }
  9629 
  9630 
  9631 
  9632 /***********************************************************************
  9633              Moving an iterator without producing glyphs
  9634  ***********************************************************************/
  9635 
  9636 /* Check if iterator is at a position corresponding to a valid buffer
  9637    position after some move_it_ call.  */
  9638 
  9639 #define IT_POS_VALID_AFTER_MOVE_P(it)                   \
  9640   ((it)->method != GET_FROM_STRING || IT_STRING_CHARPOS (*it) == 0)
  9641 
  9642 
  9643 /* Move iterator IT to a specified buffer or X position within one
  9644    line on the display without producing glyphs.
  9645 
  9646    OP should be a bit mask including some or all of these bits:
  9647     MOVE_TO_X: Stop upon reaching x-position TO_X.
  9648     MOVE_TO_POS: Stop upon reaching buffer or string position TO_CHARPOS.
  9649    Regardless of OP's value, stop upon reaching the end of the display line.
  9650 
  9651    TO_X is normally a value 0 <= TO_X <= IT->last_visible_x.
  9652    This means, in particular, that TO_X includes window's horizontal
  9653    scroll amount.
  9654 
  9655    The return value has several possible values that
  9656    say what condition caused the scan to stop:
  9657 
  9658    MOVE_POS_MATCH_OR_ZV
  9659      - when TO_POS or ZV was reached.
  9660 
  9661    MOVE_X_REACHED
  9662      -when TO_X was reached before TO_POS or ZV were reached.
  9663 
  9664    MOVE_LINE_CONTINUED
  9665      - when we reached the end of the display area and the line must
  9666      be continued.
  9667 
  9668    MOVE_LINE_TRUNCATED
  9669      - when we reached the end of the display area and the line is
  9670      truncated.
  9671 
  9672    MOVE_NEWLINE_OR_CR
  9673      - when we stopped at a line end, i.e. a newline or a CR and selective
  9674      display is on.  */
  9675 
  9676 static enum move_it_result
  9677 move_it_in_display_line_to (struct it *it,
  9678                             ptrdiff_t to_charpos, int to_x,
  9679                             enum move_operation_enum op)
  9680 {
  9681   enum move_it_result result = MOVE_UNDEFINED;
  9682   struct glyph_row *saved_glyph_row;
  9683   struct it wrap_it, atpos_it, atx_it, ppos_it;
  9684   void *wrap_data = NULL, *atpos_data = NULL, *atx_data = NULL;
  9685   void *ppos_data = NULL;
  9686   bool may_wrap = false;
  9687   enum it_method prev_method = it->method;
  9688   ptrdiff_t closest_pos UNINIT;
  9689   ptrdiff_t prev_pos = IT_CHARPOS (*it);
  9690   bool saw_smaller_pos = prev_pos < to_charpos;
  9691   bool line_number_pending = false;
  9692 
  9693   /* Don't produce glyphs in produce_glyphs.  */
  9694   saved_glyph_row = it->glyph_row;
  9695   it->glyph_row = NULL;
  9696 
  9697   /* Use wrap_it to save a copy of IT wherever a word wrap could
  9698      occur.  Use atpos_it to save a copy of IT at the desired buffer
  9699      position, if found, so that we can scan ahead and check if the
  9700      word later overshoots the window edge.  Use atx_it similarly, for
  9701      pixel positions.  */
  9702   wrap_it.sp = -1;
  9703   atpos_it.sp = -1;
  9704   atx_it.sp = -1;
  9705 
  9706   /* Use ppos_it under bidi reordering to save a copy of IT for the
  9707      initial position.  We restore that position in IT when we have
  9708      scanned the entire display line without finding a match for
  9709      TO_CHARPOS and all the character positions are greater than
  9710      TO_CHARPOS.  We then restart the scan from the initial position,
  9711      and stop at CLOSEST_POS, which is a position > TO_CHARPOS that is
  9712      the closest to TO_CHARPOS.  */
  9713   if (it->bidi_p)
  9714     {
  9715       if ((op & MOVE_TO_POS) && IT_CHARPOS (*it) >= to_charpos)
  9716         {
  9717           SAVE_IT (ppos_it, *it, ppos_data);
  9718           closest_pos = IT_CHARPOS (*it);
  9719         }
  9720       else
  9721         closest_pos = ZV;
  9722     }
  9723 
  9724 #define BUFFER_POS_REACHED_P()                                  \
  9725   ((op & MOVE_TO_POS) != 0                                      \
  9726    && BUFFERP (it->object)                                      \
  9727    && (IT_CHARPOS (*it) == to_charpos                           \
  9728        || ((!it->bidi_p                                         \
  9729             || BIDI_AT_BASE_LEVEL (it->bidi_it))                \
  9730            && IT_CHARPOS (*it) > to_charpos)                    \
  9731        || (it->what == IT_COMPOSITION                           \
  9732            && ((IT_CHARPOS (*it) > to_charpos                   \
  9733                 && to_charpos >= it->cmp_it.charpos)            \
  9734                || (IT_CHARPOS (*it) < to_charpos                \
  9735                    && to_charpos <= it->cmp_it.charpos))))      \
  9736    && (it->method == GET_FROM_BUFFER                            \
  9737        || (it->method == GET_FROM_DISPLAY_VECTOR                \
  9738            && it->dpvec + it->current.dpvec_index + 1 >= it->dpend)))
  9739 
  9740   if (it->hpos == 0)
  9741     {
  9742       /* If line numbers are being displayed, produce a line number.
  9743          But don't do that if we are to reach first_visible_x, because
  9744          line numbers are not relevant to stuff that is not visible on
  9745          display.  */
  9746       if (!((op && MOVE_TO_X) && to_x == it->first_visible_x)
  9747           && should_produce_line_number (it))
  9748         {
  9749           if (it->current_x == it->first_visible_x)
  9750             maybe_produce_line_number (it);
  9751           else
  9752             line_number_pending = true;
  9753         }
  9754       /* If there's a line-/wrap-prefix, handle it, if we didn't already.  */
  9755       if (it->area == TEXT_AREA && !it->string_from_prefix_prop_p)
  9756         handle_line_prefix (it);
  9757     }
  9758 
  9759   if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
  9760     SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
  9761 
  9762   while (true)
  9763     {
  9764       int x, i, ascent = 0, descent = 0;
  9765 
  9766 /* Utility macro to reset an iterator with x, ascent, and descent.  */
  9767 #define IT_RESET_X_ASCENT_DESCENT(IT)                   \
  9768   ((IT)->current_x = x, (IT)->max_ascent = ascent,      \
  9769    (IT)->max_descent = descent)
  9770 
  9771       /* Stop if we move beyond TO_CHARPOS (after an image or a
  9772          display string or stretch glyph).  */
  9773       if ((op & MOVE_TO_POS) != 0
  9774           && BUFFERP (it->object)
  9775           && it->method == GET_FROM_BUFFER
  9776           && (((!it->bidi_p
  9777                 /* When the iterator is at base embedding level, we
  9778                    are guaranteed that characters are delivered for
  9779                    display in strictly increasing order of their
  9780                    buffer positions.  */
  9781                 || BIDI_AT_BASE_LEVEL (it->bidi_it))
  9782                && IT_CHARPOS (*it) > to_charpos)
  9783               || (it->bidi_p
  9784                   && (prev_method == GET_FROM_IMAGE
  9785                       || prev_method == GET_FROM_STRETCH
  9786                       || prev_method == GET_FROM_STRING)
  9787                   /* Passed TO_CHARPOS from left to right.  */
  9788                   && ((prev_pos < to_charpos
  9789                        && IT_CHARPOS (*it) >= to_charpos)
  9790                       /* Passed TO_CHARPOS from right to left.  */
  9791                       || (prev_pos > to_charpos
  9792                           && IT_CHARPOS (*it) <= to_charpos)))))
  9793         {
  9794           if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
  9795             {
  9796               result = MOVE_POS_MATCH_OR_ZV;
  9797               break;
  9798             }
  9799           else if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
  9800             /* If wrap_it is valid, the current position might be in a
  9801                word that is wrapped.  So, save the iterator in
  9802                atpos_it and continue to see if wrapping happens.  */
  9803             SAVE_IT (atpos_it, *it, atpos_data);
  9804         }
  9805 
  9806       /* Stop when ZV reached.
  9807          We used to stop here when TO_CHARPOS reached as well, but that is
  9808          too soon if this glyph does not fit on this line.  So we handle it
  9809          explicitly below.  */
  9810       if (!get_next_display_element (it))
  9811         {
  9812           result = MOVE_POS_MATCH_OR_ZV;
  9813           break;
  9814         }
  9815 
  9816       if (it->line_wrap == TRUNCATE)
  9817         {
  9818           /* If it->pixel_width is zero, the last PRODUCE_GLYPHS call
  9819              produced something that doesn't consume any screen estate
  9820              in the text area, so we don't want to exit the loop at
  9821              TO_CHARPOS, before we produce the glyph for that buffer
  9822              position.  This happens, e.g., when there's an overlay at
  9823              TO_CHARPOS that draws a fringe bitmap.  */
  9824           if (BUFFER_POS_REACHED_P ()
  9825               && (it->pixel_width > 0
  9826                   || IT_CHARPOS (*it) > to_charpos
  9827                   || it->area != TEXT_AREA))
  9828             {
  9829               result = MOVE_POS_MATCH_OR_ZV;
  9830               break;
  9831             }
  9832         }
  9833       else
  9834         {
  9835           if (it->line_wrap == WORD_WRAP && it->area == TEXT_AREA)
  9836             {
  9837               bool next_may_wrap = may_wrap;
  9838               /* Can we wrap after this character?  */
  9839               if (char_can_wrap_after (it))
  9840                 next_may_wrap = true;
  9841               else
  9842                 next_may_wrap = false;
  9843               /* Can we wrap here? */
  9844               if (may_wrap && char_can_wrap_before (it))
  9845                 {
  9846                   /* We have reached a glyph that follows one or more
  9847                      whitespace characters or characters that allow
  9848                      wrapping after them.  If this character allows
  9849                      wrapping before it, save this position as a
  9850                      wrapping point.  */
  9851                   if (atpos_it.sp >= 0)
  9852                     {
  9853                       RESTORE_IT (it, &atpos_it, atpos_data);
  9854                       result = MOVE_POS_MATCH_OR_ZV;
  9855                       goto done;
  9856                     }
  9857                   if (atx_it.sp >= 0)
  9858                     {
  9859                       RESTORE_IT (it, &atx_it, atx_data);
  9860                       result = MOVE_X_REACHED;
  9861                       goto done;
  9862                     }
  9863                   /* Otherwise, we can wrap here.  */
  9864                   SAVE_IT (wrap_it, *it, wrap_data);
  9865                 }
  9866               /* Update may_wrap for the next iteration.  */
  9867               may_wrap = next_may_wrap;
  9868             }
  9869         }
  9870 
  9871       /* Remember the line height for the current line, in case
  9872          the next element doesn't fit on the line.  */
  9873       ascent = it->max_ascent;
  9874       descent = it->max_descent;
  9875 
  9876       /* The call to produce_glyphs will get the metrics of the
  9877          display element IT is loaded with.  Record the x-position
  9878          before this display element, in case it doesn't fit on the
  9879          line.  */
  9880       x = it->current_x;
  9881 
  9882       PRODUCE_GLYPHS (it);
  9883 
  9884       if (it->area != TEXT_AREA)
  9885         {
  9886           prev_method = it->method;
  9887           if (it->method == GET_FROM_BUFFER)
  9888             prev_pos = IT_CHARPOS (*it);
  9889           set_iterator_to_next (it, true);
  9890           if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
  9891             SET_TEXT_POS (this_line_min_pos,
  9892                           IT_CHARPOS (*it), IT_BYTEPOS (*it));
  9893           if (it->bidi_p
  9894               && (op & MOVE_TO_POS)
  9895               && IT_CHARPOS (*it) > to_charpos
  9896               && IT_CHARPOS (*it) < closest_pos)
  9897             closest_pos = IT_CHARPOS (*it);
  9898           continue;
  9899         }
  9900 
  9901       /* The number of glyphs we get back in IT->nglyphs will normally
  9902          be 1 except when IT->c is (i) a TAB, or (ii) a multi-glyph
  9903          character on a terminal frame, or (iii) a line end.  For the
  9904          second case, IT->nglyphs - 1 padding glyphs will be present.
  9905          (On X frames, there is only one glyph produced for a
  9906          composite character.)
  9907 
  9908          The behavior implemented below means, for continuation lines,
  9909          that as many spaces of a TAB as fit on the current line are
  9910          displayed there.  For terminal frames, as many glyphs of a
  9911          multi-glyph character are displayed in the current line, too.
  9912          This is what the old redisplay code did, and we keep it that
  9913          way.  Under X, the whole shape of a complex character must
  9914          fit on the line or it will be completely displayed in the
  9915          next line.
  9916 
  9917          Note that both for tabs and padding glyphs, all glyphs have
  9918          the same width.  */
  9919       if (it->nglyphs)
  9920         {
  9921           /* More than one glyph or glyph doesn't fit on line.  All
  9922              glyphs have the same width.  */
  9923           int single_glyph_width = it->pixel_width / it->nglyphs;
  9924           int new_x;
  9925           int x_before_this_char = x;
  9926           int hpos_before_this_char = it->hpos;
  9927 
  9928           for (i = 0; i < it->nglyphs; ++i, x = new_x)
  9929             {
  9930               new_x = x + single_glyph_width;
  9931 
  9932               /* We want to leave anything reaching TO_X to the caller.  */
  9933               if ((op & MOVE_TO_X) && new_x > to_x)
  9934                 {
  9935                   if (BUFFER_POS_REACHED_P ())
  9936                     {
  9937                       if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
  9938                         goto buffer_pos_reached;
  9939                       if (atpos_it.sp < 0)
  9940                         {
  9941                           SAVE_IT (atpos_it, *it, atpos_data);
  9942                           IT_RESET_X_ASCENT_DESCENT (&atpos_it);
  9943                         }
  9944                     }
  9945                   else
  9946                     {
  9947                       if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
  9948                         {
  9949                           it->current_x = x;
  9950                           result = MOVE_X_REACHED;
  9951                           break;
  9952                         }
  9953                       if (atx_it.sp < 0)
  9954                         {
  9955                           SAVE_IT (atx_it, *it, atx_data);
  9956                           IT_RESET_X_ASCENT_DESCENT (&atx_it);
  9957                         }
  9958                     }
  9959                 }
  9960 
  9961               if (/* Lines are continued.  */
  9962                   it->line_wrap != TRUNCATE
  9963                   && (/* And glyph doesn't fit on the line.  */
  9964                       new_x > it->last_visible_x
  9965                       /* Or it fits exactly and we're on a window
  9966                          system frame.  */
  9967                       || (new_x == it->last_visible_x
  9968                           && FRAME_WINDOW_P (it->f)
  9969                           && ((it->bidi_p && it->bidi_it.paragraph_dir == R2L)
  9970                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
  9971                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w)))))
  9972                 {
  9973                   bool moved_forward = false;
  9974 
  9975                   if (/* IT->hpos == 0 means the very first glyph
  9976                          doesn't fit on the line, e.g. a wide image.  */
  9977                       it->hpos == 0
  9978                       || (new_x == it->last_visible_x
  9979                           && FRAME_WINDOW_P (it->f)))
  9980                     {
  9981                       ++it->hpos;
  9982                       it->current_x = new_x;
  9983 
  9984                       /* The character's last glyph just barely fits
  9985                          in this row.  */
  9986                       if (i == it->nglyphs - 1)
  9987                         {
  9988                           /* If this is the destination position,
  9989                              return a position *before* it in this row,
  9990                              now that we know it fits in this row.  */
  9991                           if (BUFFER_POS_REACHED_P ())
  9992                             {
  9993                               bool can_wrap = true;
  9994 
  9995                               /* If the previous character says we can
  9996                                  wrap after it, but the current
  9997                                  character says we can't wrap before
  9998                                  it, then we can't wrap here.  */
  9999                               if (it->line_wrap == WORD_WRAP
 10000                                   && wrap_it.sp >= 0
 10001                                   && may_wrap
 10002                                   && IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10003                                 {
 10004                                   struct it tem_it;
 10005                                   void *tem_data = NULL;
 10006 
 10007                                   SAVE_IT (tem_it, *it, tem_data);
 10008                                   set_iterator_to_next (it, true);
 10009                                   if (get_next_display_element (it)
 10010                                       && !char_can_wrap_before (it))
 10011                                     can_wrap = false;
 10012                                   RESTORE_IT (it, &tem_it, tem_data);
 10013                                 }
 10014                               if (it->line_wrap != WORD_WRAP
 10015                                   || wrap_it.sp < 0
 10016                                   /* If we've just found whitespace
 10017                                      where we can wrap, effectively
 10018                                      ignore the previous wrap point --
 10019                                      it is no longer relevant, but we
 10020                                      won't have an opportunity to
 10021                                      update it, since we've reached
 10022                                      the edge of this screen line.  */
 10023                                   || (may_wrap && can_wrap
 10024                                       && IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)))
 10025                                 {
 10026                                   it->hpos = hpos_before_this_char;
 10027                                   it->current_x = x_before_this_char;
 10028                                   result = MOVE_POS_MATCH_OR_ZV;
 10029                                   break;
 10030                                 }
 10031                               if (it->line_wrap == WORD_WRAP
 10032                                   && atpos_it.sp < 0)
 10033                                 {
 10034                                   SAVE_IT (atpos_it, *it, atpos_data);
 10035                                   atpos_it.current_x = x_before_this_char;
 10036                                   atpos_it.hpos = hpos_before_this_char;
 10037                                 }
 10038                             }
 10039 
 10040                           prev_method = it->method;
 10041                           if (it->method == GET_FROM_BUFFER)
 10042                             prev_pos = IT_CHARPOS (*it);
 10043                           set_iterator_to_next (it, true);
 10044                           if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
 10045                             SET_TEXT_POS (this_line_min_pos,
 10046                                           IT_CHARPOS (*it), IT_BYTEPOS (*it));
 10047                           /* On graphical terminals, newlines may
 10048                              "overflow" into the fringe if
 10049                              overflow-newline-into-fringe is non-nil.
 10050                              On text terminals, and on graphical
 10051                              terminals with no right margin, newlines
 10052                              may overflow into the last glyph on the
 10053                              display line.*/
 10054                           if (!FRAME_WINDOW_P (it->f)
 10055                               || ((it->bidi_p
 10056                                    && it->bidi_it.paragraph_dir == R2L)
 10057                                   ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 10058                                   : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0
 10059                               || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10060                             {
 10061                               if (!get_next_display_element (it))
 10062                                 {
 10063                                   result = MOVE_POS_MATCH_OR_ZV;
 10064                                   break;
 10065                                 }
 10066                               moved_forward = true;
 10067                               if (BUFFER_POS_REACHED_P ())
 10068                                 {
 10069                                   if (ITERATOR_AT_END_OF_LINE_P (it))
 10070                                     result = MOVE_POS_MATCH_OR_ZV;
 10071                                   else
 10072                                     result = MOVE_LINE_CONTINUED;
 10073                                   break;
 10074                                 }
 10075                               if (ITERATOR_AT_END_OF_LINE_P (it)
 10076                                   && (it->line_wrap != WORD_WRAP
 10077                                       || wrap_it.sp < 0
 10078                                       || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)))
 10079                                 {
 10080                                   result = MOVE_NEWLINE_OR_CR;
 10081                                   break;
 10082                                 }
 10083                             }
 10084                         }
 10085                     }
 10086                   else
 10087                     IT_RESET_X_ASCENT_DESCENT (it);
 10088 
 10089                   /* If the screen line ends with whitespace (or
 10090                      wrap-able character), and we are under word-wrap,
 10091                      don't use wrap_it: it is no longer relevant, but
 10092                      we won't have an opportunity to update it, since
 10093                      we are done with this screen line.  */
 10094                   if (may_wrap && IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)
 10095                       /* If the character after the one which set the
 10096                          may_wrap flag says we can't wrap before it,
 10097                          we can't wrap here.  Therefore, wrap_it
 10098                          (previously found wrap-point) _is_ relevant
 10099                          in that case.  */
 10100                       && (!moved_forward || char_can_wrap_before (it)))
 10101                     {
 10102                       /* If we've found TO_X, go back there, as we now
 10103                          know the last word fits on this screen line.  */
 10104                       if ((op & MOVE_TO_X) && new_x == it->last_visible_x
 10105                           && atx_it.sp >= 0)
 10106                         {
 10107                           RESTORE_IT (it, &atx_it, atx_data);
 10108                           atpos_it.sp = -1;
 10109                           atx_it.sp = -1;
 10110                           result = MOVE_X_REACHED;
 10111                           break;
 10112                         }
 10113                     }
 10114                   else if (wrap_it.sp >= 0)
 10115                     {
 10116                       RESTORE_IT (it, &wrap_it, wrap_data);
 10117                       atpos_it.sp = -1;
 10118                       atx_it.sp = -1;
 10119                     }
 10120 
 10121                   move_trace ("move_it_in: continued at %td\n",
 10122                               IT_CHARPOS (*it));
 10123                   result = MOVE_LINE_CONTINUED;
 10124                   break;
 10125                 }
 10126 
 10127               if (BUFFER_POS_REACHED_P ())
 10128                 {
 10129                   if (it->line_wrap != WORD_WRAP || wrap_it.sp < 0)
 10130                     goto buffer_pos_reached;
 10131                   if (it->line_wrap == WORD_WRAP && atpos_it.sp < 0)
 10132                     {
 10133                       SAVE_IT (atpos_it, *it, atpos_data);
 10134                       IT_RESET_X_ASCENT_DESCENT (&atpos_it);
 10135                     }
 10136                 }
 10137 
 10138               if (new_x > it->first_visible_x)
 10139                 {
 10140                   /* If we have reached the visible portion of the
 10141                      screen line, produce the line number if needed.  */
 10142                   if (line_number_pending)
 10143                     {
 10144                       line_number_pending = false;
 10145                       it->current_x = it->first_visible_x;
 10146                       maybe_produce_line_number (it);
 10147                       it->current_x += new_x - it->first_visible_x;
 10148                     }
 10149                   /* Glyph is visible.  Increment number of glyphs that
 10150                      would be displayed.  */
 10151                   ++it->hpos;
 10152                 }
 10153             }
 10154 
 10155           if (result != MOVE_UNDEFINED)
 10156             break;
 10157         }
 10158       else if (BUFFER_POS_REACHED_P ())
 10159         {
 10160         buffer_pos_reached:
 10161           IT_RESET_X_ASCENT_DESCENT (it);
 10162           result = MOVE_POS_MATCH_OR_ZV;
 10163           break;
 10164         }
 10165       else if ((op & MOVE_TO_X) && it->current_x >= to_x)
 10166         {
 10167           /* Stop when TO_X specified and reached.  This check is
 10168              necessary here because of lines consisting of a line end,
 10169              only.  The line end will not produce any glyphs and we
 10170              would never get MOVE_X_REACHED.  */
 10171           eassert (it->nglyphs == 0);
 10172           result = MOVE_X_REACHED;
 10173           break;
 10174         }
 10175 
 10176       /* Is this a line end?  If yes, we're done.  */
 10177       if (ITERATOR_AT_END_OF_LINE_P (it))
 10178         {
 10179           /* If we are past TO_CHARPOS, but never saw any character
 10180              positions smaller than TO_CHARPOS, return
 10181              MOVE_POS_MATCH_OR_ZV, like the unidirectional display
 10182              did.  */
 10183           if (it->bidi_p && (op & MOVE_TO_POS) != 0)
 10184             {
 10185               if (!saw_smaller_pos && IT_CHARPOS (*it) > to_charpos)
 10186                 {
 10187                   if (closest_pos < ZV)
 10188                     {
 10189                       RESTORE_IT (it, &ppos_it, ppos_data);
 10190                       /* Don't recurse if closest_pos is equal to
 10191                          to_charpos, since we have just tried that.  */
 10192                       if (closest_pos != to_charpos)
 10193                         move_it_in_display_line_to (it, closest_pos, -1,
 10194                                                     MOVE_TO_POS);
 10195                       result = MOVE_POS_MATCH_OR_ZV;
 10196                     }
 10197                   else
 10198                     goto buffer_pos_reached;
 10199                 }
 10200               else if (it->line_wrap == WORD_WRAP && atpos_it.sp >= 0
 10201                        && IT_CHARPOS (*it) > to_charpos)
 10202                 goto buffer_pos_reached;
 10203               else
 10204                 result = MOVE_NEWLINE_OR_CR;
 10205             }
 10206           else
 10207             result = MOVE_NEWLINE_OR_CR;
 10208           /* If lines are truncated, and the line we moved across is
 10209              completely hscrolled out of view, reset the line metrics
 10210              to those of the newline we've just processed, so that
 10211              glyphs not on display don't affect the line's height.  */
 10212           if (it->line_wrap == TRUNCATE
 10213               && it->current_x <= it->first_visible_x
 10214               && result == MOVE_NEWLINE_OR_CR
 10215               && it->char_to_display == '\n')
 10216             {
 10217               it->max_ascent = it->ascent;
 10218               it->max_descent = it->descent;
 10219             }
 10220           /* If we've processed the newline, make sure this flag is
 10221              reset, as it must only be set when the newline itself is
 10222              processed.  */
 10223           if (result == MOVE_NEWLINE_OR_CR)
 10224             it->constrain_row_ascent_descent_p = false;
 10225           break;
 10226         }
 10227 
 10228       prev_method = it->method;
 10229       if (it->method == GET_FROM_BUFFER)
 10230         prev_pos = IT_CHARPOS (*it);
 10231 
 10232       /* Detect overly-wide wrap-prefixes made of (space ...) display
 10233          properties.  When such a wrap prefix reaches past the right
 10234          margin of the window, we need to avoid the call to
 10235          set_iterator_to_next below, so that it->line_wrap is left at
 10236          its TRUNCATE value wisely set by handle_line_prefix.
 10237          Otherwise, set_iterator_to_next will pop the iterator stack,
 10238          restore it->line_wrap, and we might miss the opportunity to
 10239          exit the loop and return.  */
 10240       bool overwide_wrap_prefix =
 10241         CONSP (it->object) && EQ (XCAR (it->object), Qspace)
 10242         && it->sp > 0 && it->method == GET_FROM_STRETCH
 10243         && it->current_x >= it->last_visible_x
 10244         && it->continuation_lines_width > 0
 10245         && it->line_wrap == TRUNCATE && it->stack[0].line_wrap != TRUNCATE;
 10246       /* The current display element has been consumed.  Advance
 10247          to the next.  */
 10248       if (!overwide_wrap_prefix)
 10249         set_iterator_to_next (it, true);
 10250       if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
 10251         SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
 10252       if (IT_CHARPOS (*it) < to_charpos)
 10253         saw_smaller_pos = true;
 10254       if (it->bidi_p
 10255           && (op & MOVE_TO_POS)
 10256           && IT_CHARPOS (*it) >= to_charpos
 10257           && IT_CHARPOS (*it) < closest_pos)
 10258         closest_pos = IT_CHARPOS (*it);
 10259 
 10260       /* Stop if lines are truncated and IT's current x-position is
 10261          past the right edge of the window now.  */
 10262       if (it->line_wrap == TRUNCATE
 10263           && it->current_x >= it->last_visible_x)
 10264         {
 10265           if (!FRAME_WINDOW_P (it->f)
 10266               || ((it->bidi_p && it->bidi_it.paragraph_dir == R2L)
 10267                   ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 10268                   : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0
 10269               || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10270             {
 10271               bool at_eob_p = false;
 10272 
 10273               if ((at_eob_p = !get_next_display_element (it))
 10274                   || BUFFER_POS_REACHED_P ()
 10275                   /* If we are past TO_CHARPOS, but never saw any
 10276                      character positions smaller than TO_CHARPOS,
 10277                      return MOVE_POS_MATCH_OR_ZV, like the
 10278                      unidirectional display did.  */
 10279                   || (it->bidi_p && (op & MOVE_TO_POS) != 0
 10280                       && !saw_smaller_pos
 10281                       && IT_CHARPOS (*it) > to_charpos))
 10282                 {
 10283                   if (it->bidi_p
 10284                       && !BUFFER_POS_REACHED_P ()
 10285                       && !at_eob_p && closest_pos < ZV)
 10286                     {
 10287                       RESTORE_IT (it, &ppos_it, ppos_data);
 10288                       if (closest_pos != to_charpos)
 10289                         move_it_in_display_line_to (it, closest_pos, -1,
 10290                                                     MOVE_TO_POS);
 10291                     }
 10292                   result = MOVE_POS_MATCH_OR_ZV;
 10293                   break;
 10294                 }
 10295               if (ITERATOR_AT_END_OF_LINE_P (it))
 10296                 {
 10297                   result = MOVE_NEWLINE_OR_CR;
 10298                   break;
 10299                 }
 10300             }
 10301           else if (it->bidi_p && (op & MOVE_TO_POS) != 0
 10302                    && !saw_smaller_pos
 10303                    && IT_CHARPOS (*it) > to_charpos)
 10304             {
 10305               if (closest_pos < ZV)
 10306                 {
 10307                   RESTORE_IT (it, &ppos_it, ppos_data);
 10308                   if (closest_pos != to_charpos)
 10309                     move_it_in_display_line_to (it, closest_pos, -1,
 10310                                                 MOVE_TO_POS);
 10311                 }
 10312               result = MOVE_POS_MATCH_OR_ZV;
 10313               break;
 10314             }
 10315           result = MOVE_LINE_TRUNCATED;
 10316           break;
 10317         }
 10318 #undef IT_RESET_X_ASCENT_DESCENT
 10319     }
 10320 
 10321 #undef BUFFER_POS_REACHED_P
 10322 
 10323   /* If we scanned beyond TO_POS, restore the saved iterator either to
 10324      the wrap point (if found), or to atpos/atx location.  We decide which
 10325      data to use to restore the saved iterator state by their X coordinates,
 10326      since buffer positions might increase non-monotonically with screen
 10327      coordinates due to bidi reordering.  */
 10328   if (result == MOVE_LINE_CONTINUED
 10329       && it->line_wrap == WORD_WRAP
 10330       && wrap_it.sp >= 0
 10331       && ((atpos_it.sp >= 0 && wrap_it.current_x < atpos_it.current_x)
 10332           || (atx_it.sp >= 0 && wrap_it.current_x < atx_it.current_x)))
 10333     RESTORE_IT (it, &wrap_it, wrap_data);
 10334   else if (atpos_it.sp >= 0)
 10335     RESTORE_IT (it, &atpos_it, atpos_data);
 10336   else if (atx_it.sp >= 0)
 10337     RESTORE_IT (it, &atx_it, atx_data);
 10338 
 10339  done:
 10340 
 10341   if (atpos_data)
 10342     bidi_unshelve_cache (atpos_data, true);
 10343   if (atx_data)
 10344     bidi_unshelve_cache (atx_data, true);
 10345   if (wrap_data)
 10346     bidi_unshelve_cache (wrap_data, true);
 10347   if (ppos_data)
 10348     bidi_unshelve_cache (ppos_data, true);
 10349 
 10350   /* Restore the iterator settings altered at the beginning of this
 10351      function.  */
 10352   it->glyph_row = saved_glyph_row;
 10353   return result;
 10354 }
 10355 
 10356 /* For external use.  */
 10357 void
 10358 move_it_in_display_line (struct it *it,
 10359                          ptrdiff_t to_charpos, int to_x,
 10360                          enum move_operation_enum op)
 10361 {
 10362   if (it->line_wrap == WORD_WRAP
 10363       && (op & MOVE_TO_X))
 10364     {
 10365       struct it save_it;
 10366       void *save_data = NULL;
 10367       int skip;
 10368 
 10369       SAVE_IT (save_it, *it, save_data);
 10370       skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
 10371       /* When word-wrap is on, TO_X may lie past the end
 10372          of a wrapped line.  Then it->current is the
 10373          character on the next line, so backtrack to the
 10374          space before the wrap point.  */
 10375       if (skip == MOVE_LINE_CONTINUED)
 10376         {
 10377           int prev_x = max (it->current_x - 1, 0);
 10378           RESTORE_IT (it, &save_it, save_data);
 10379           move_it_in_display_line_to
 10380             (it, -1, prev_x, MOVE_TO_X);
 10381         }
 10382       else
 10383         bidi_unshelve_cache (save_data, true);
 10384     }
 10385   else
 10386     move_it_in_display_line_to (it, to_charpos, to_x, op);
 10387 }
 10388 
 10389 
 10390 /* Move IT forward until it satisfies one or more of the criteria in
 10391    TO_CHARPOS, TO_X, TO_Y, and TO_VPOS.
 10392 
 10393    OP is a bit-mask that specifies where to stop, and in particular,
 10394    which of those four position arguments makes a difference.  See the
 10395    description of enum move_operation_enum.
 10396 
 10397    If TO_CHARPOS is in invisible text, e.g. a truncated part of a
 10398    screen line, this function will set IT to the next position that is
 10399    displayed to the right of TO_CHARPOS on the screen.
 10400 
 10401    Return the maximum pixel length of any line scanned but never more
 10402    than it.last_visible_x.  */
 10403 
 10404 int
 10405 move_it_to (struct it *it, ptrdiff_t to_charpos, int to_x, int to_y, int to_vpos, int op)
 10406 {
 10407   enum move_it_result skip, skip2 = MOVE_X_REACHED;
 10408   int line_height, line_start_x = 0, reached = 0;
 10409   int max_current_x = 0;
 10410   void *backup_data = NULL;
 10411   ptrdiff_t orig_charpos = -1;
 10412   enum it_method orig_method = NUM_IT_METHODS;
 10413 
 10414   for (;;)
 10415     {
 10416       orig_charpos = IT_CHARPOS (*it);
 10417       orig_method = it->method;
 10418       if (op & MOVE_TO_VPOS)
 10419         {
 10420           /* If no TO_CHARPOS and no TO_X specified, stop at the
 10421              start of the line TO_VPOS.  */
 10422           if ((op & (MOVE_TO_X | MOVE_TO_POS)) == 0)
 10423             {
 10424               if (it->vpos == to_vpos)
 10425                 {
 10426                   reached = 1;
 10427                   break;
 10428                 }
 10429               else
 10430                 skip = move_it_in_display_line_to (it, -1, -1, 0);
 10431             }
 10432           else
 10433             {
 10434               /* TO_VPOS >= 0 means stop at TO_X in the line at
 10435                  TO_VPOS, or at TO_POS, whichever comes first.  */
 10436               if (it->vpos == to_vpos)
 10437                 {
 10438                   reached = 2;
 10439                   break;
 10440                 }
 10441 
 10442               skip = move_it_in_display_line_to (it, to_charpos, to_x, op);
 10443 
 10444               if (skip == MOVE_POS_MATCH_OR_ZV || it->vpos == to_vpos)
 10445                 {
 10446                   reached = 3;
 10447                   break;
 10448                 }
 10449               else if (skip == MOVE_X_REACHED && it->vpos != to_vpos)
 10450                 {
 10451                   /* We have reached TO_X but not in the line we want.  */
 10452                   skip = move_it_in_display_line_to (it, to_charpos,
 10453                                                      -1, MOVE_TO_POS);
 10454                   if (skip == MOVE_POS_MATCH_OR_ZV)
 10455                     {
 10456                       reached = 4;
 10457                       break;
 10458                     }
 10459                 }
 10460             }
 10461         }
 10462       else if (op & MOVE_TO_Y)
 10463         {
 10464           struct it it_backup;
 10465 
 10466           if (it->line_wrap == WORD_WRAP)
 10467             SAVE_IT (it_backup, *it, backup_data);
 10468 
 10469           /* TO_Y specified means stop at TO_X in the line containing
 10470              TO_Y---or at TO_CHARPOS if this is reached first.  The
 10471              problem is that we can't really tell whether the line
 10472              contains TO_Y before we have completely scanned it, and
 10473              this may skip past TO_X.  What we do is to first scan to
 10474              TO_X.
 10475 
 10476              If TO_X is not specified, use a TO_X of zero.  The reason
 10477              is to make the outcome of this function more predictable.
 10478              If we didn't use TO_X == 0, we would stop at the end of
 10479              the line which is probably not what a caller would expect
 10480              to happen.  */
 10481           skip = move_it_in_display_line_to
 10482             (it, to_charpos, ((op & MOVE_TO_X) ? to_x : 0),
 10483              (MOVE_TO_X | (op & MOVE_TO_POS)));
 10484 
 10485           /* If TO_CHARPOS is reached or ZV, we don't have to do more.  */
 10486           if (skip == MOVE_POS_MATCH_OR_ZV)
 10487             reached = 5;
 10488           else if (skip == MOVE_X_REACHED)
 10489             {
 10490               /* If TO_X was reached, we want to know whether TO_Y is
 10491                  in the line.  We know this is the case if the already
 10492                  scanned glyphs make the line tall enough.  Otherwise,
 10493                  we must check by scanning the rest of the line.  */
 10494               line_height = it->max_ascent + it->max_descent;
 10495               if (to_y >= it->current_y
 10496                   && to_y < it->current_y + line_height)
 10497                 {
 10498                   reached = 6;
 10499                   break;
 10500                 }
 10501               SAVE_IT (it_backup, *it, backup_data);
 10502               move_trace ("move_it: from %td\n", IT_CHARPOS (*it));
 10503               skip2 = move_it_in_display_line_to (it, to_charpos, -1,
 10504                                                   op & MOVE_TO_POS);
 10505               move_trace ("move_it: to %td\n", IT_CHARPOS (*it));
 10506               line_height = it->max_ascent + it->max_descent;
 10507               move_trace ("move_it: line_height = %d\n", line_height);
 10508 
 10509               if (to_y >= it->current_y
 10510                   && to_y < it->current_y + line_height)
 10511                 {
 10512                   /* If TO_Y is in this line and TO_X was reached
 10513                      above, we scanned too far.  We have to restore
 10514                      IT's settings to the ones before skipping.  But
 10515                      keep the more accurate values of max_ascent and
 10516                      max_descent we've found while skipping the rest
 10517                      of the line, for the sake of callers, such as
 10518                      pos_visible_p, that need to know the line
 10519                      height.  */
 10520                   int max_ascent = it->max_ascent;
 10521                   int max_descent = it->max_descent;
 10522 
 10523                   RESTORE_IT (it, &it_backup, backup_data);
 10524                   it->max_ascent = max_ascent;
 10525                   it->max_descent = max_descent;
 10526                   reached = 6;
 10527                 }
 10528               else
 10529                 {
 10530                   skip = skip2;
 10531                   if (skip == MOVE_POS_MATCH_OR_ZV)
 10532                     {
 10533                       reached = 7;
 10534                       /* If the last move_it_in_display_line_to call
 10535                          took us away from TO_CHARPOS, back up to the
 10536                          previous position, as it is a better
 10537                          approximation of TO_CHARPOS.  (Note that we
 10538                          could have both positions after TO_CHARPOS or
 10539                          both positions before it, due to bidi
 10540                          reordering.)  */
 10541                       if (to_charpos > 0
 10542                           && IT_CHARPOS (*it) != to_charpos
 10543                           && ((IT_CHARPOS (it_backup) > to_charpos)
 10544                               == (IT_CHARPOS (*it) > to_charpos)))
 10545                         {
 10546                           int max_ascent = it->max_ascent;
 10547                           int max_descent = it->max_descent;
 10548 
 10549                           RESTORE_IT (it, &it_backup, backup_data);
 10550                           it->max_ascent = max_ascent;
 10551                           it->max_descent = max_descent;
 10552                         }
 10553                     }
 10554                 }
 10555             }
 10556           else
 10557             {
 10558               /* Check whether TO_Y is in this line.  */
 10559               line_height = it->max_ascent + it->max_descent;
 10560               move_trace ("move_it: line_height = %d\n", line_height);
 10561 
 10562               if (to_y >= it->current_y
 10563                   && to_y < it->current_y + line_height)
 10564                 {
 10565                   if (to_y > it->current_y)
 10566                     max_current_x = max (it->current_x, max_current_x);
 10567 
 10568                   /* When word-wrap is on, TO_X may lie past the end
 10569                      of a wrapped line.  Then it->current is the
 10570                      character on the next line, so backtrack to the
 10571                      space before the wrap point.  */
 10572                   if (skip == MOVE_LINE_CONTINUED
 10573                       && it->line_wrap == WORD_WRAP)
 10574                     {
 10575                       int prev_x = max (it->current_x - 1, 0);
 10576                       RESTORE_IT (it, &it_backup, backup_data);
 10577                       skip = move_it_in_display_line_to
 10578                         (it, -1, prev_x, MOVE_TO_X);
 10579                     }
 10580 
 10581                   reached = 6;
 10582                 }
 10583             }
 10584 
 10585           if (reached)
 10586             {
 10587               max_current_x = max (it->current_x, max_current_x);
 10588               break;
 10589             }
 10590         }
 10591       else if (BUFFERP (it->object)
 10592                && (it->method == GET_FROM_BUFFER
 10593                    || it->method == GET_FROM_STRETCH)
 10594                && IT_CHARPOS (*it) >= to_charpos
 10595                /* Under bidi iteration, a call to set_iterator_to_next
 10596                   can scan far beyond to_charpos if the initial
 10597                   portion of the next line needs to be reordered.  In
 10598                   that case, give move_it_in_display_line_to another
 10599                   chance below.  */
 10600                && !(it->bidi_p
 10601                     && it->bidi_it.scan_dir == -1))
 10602         skip = MOVE_POS_MATCH_OR_ZV;
 10603       else
 10604         skip = move_it_in_display_line_to (it, to_charpos, -1, MOVE_TO_POS);
 10605 
 10606       switch (skip)
 10607         {
 10608         case MOVE_POS_MATCH_OR_ZV:
 10609           max_current_x = max (it->current_x, max_current_x);
 10610           reached = 8;
 10611           goto out;
 10612 
 10613         case MOVE_NEWLINE_OR_CR:
 10614           max_current_x = max (it->current_x, max_current_x);
 10615           if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 10616             it->override_ascent = -1;
 10617           set_iterator_to_next (it, true);
 10618           it->continuation_lines_width = 0;
 10619           break;
 10620 
 10621         case MOVE_LINE_TRUNCATED:
 10622           max_current_x = it->last_visible_x;
 10623           it->continuation_lines_width = 0;
 10624           reseat_at_next_visible_line_start (it, false);
 10625           if ((op & MOVE_TO_POS) != 0
 10626               && (IT_CHARPOS (*it) > to_charpos
 10627                   || (IT_CHARPOS (*it) == to_charpos
 10628                       /* Consider TO_CHARPOS as REACHED if we are at
 10629                          EOB that ends in something other than a newline.  */
 10630                       && to_charpos == ZV
 10631                       && (ZV_BYTE <= 1 || FETCH_BYTE (ZV_BYTE - 1) != '\n')
 10632                       /* But if we have a display or an overlay string
 10633                          at EOB, keep going until we exhaust all the
 10634                          characters of the string(s).  */
 10635                       && (it->sp == 0
 10636                           || (STRINGP (it->string)
 10637                               && (it->current.overlay_string_index < 0
 10638                                   || (it->current.overlay_string_index >= 0
 10639                                       && it->current.overlay_string_index
 10640                                          >= it->n_overlay_strings - 1))
 10641                               && IT_STRING_CHARPOS (*it) >= it->end_charpos)))))
 10642             {
 10643               reached = 9;
 10644               goto out;
 10645             }
 10646           break;
 10647 
 10648         case MOVE_LINE_CONTINUED:
 10649           max_current_x = it->last_visible_x;
 10650           /* For continued lines ending in a tab, some of the glyphs
 10651              associated with the tab are displayed on the current
 10652              line.  Since it->current_x does not include these glyphs,
 10653              we use it->last_visible_x instead.  */
 10654           if (it->c == '\t')
 10655             {
 10656               it->continuation_lines_width += it->last_visible_x;
 10657               /* When moving by vpos, ensure that the iterator really
 10658                  advances to the next line (bug#847, bug#969).  Fixme:
 10659                  do we need to do this in other circumstances?  */
 10660               if (it->current_x != it->last_visible_x
 10661                   && (op & MOVE_TO_VPOS)
 10662                   && !(op & (MOVE_TO_X | MOVE_TO_POS)))
 10663                 {
 10664                   line_start_x = it->current_x + it->pixel_width
 10665                     - it->last_visible_x;
 10666                   if (FRAME_WINDOW_P (it->f))
 10667                     {
 10668                       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 10669                       struct font *face_font = face->font;
 10670 
 10671                       /* When display_line produces a continued line
 10672                          that ends in a TAB, it skips a tab stop that
 10673                          is closer than the font's space character
 10674                          width (see gui_produce_glyphs where it produces
 10675                          the stretch glyph which represents a TAB).
 10676                          We need to reproduce the same logic here.  */
 10677                       eassert (face_font);
 10678                       if (face_font)
 10679                         {
 10680                           if (line_start_x < face_font->space_width)
 10681                             line_start_x
 10682                               += it->tab_width * face_font->space_width;
 10683                         }
 10684                     }
 10685                   set_iterator_to_next (it, false);
 10686                 }
 10687             }
 10688           else
 10689             {
 10690               /* Make sure we do advance, otherwise we might infloop.
 10691                  This could happen when the first display element is
 10692                  wider than the window, or if we have a wrap-prefix
 10693                  that doesn't leave enough space after it to display
 10694                  even a single character.  We only do this for moving
 10695                  through buffer text, as with display/overlay strings
 10696                  we'd need to also compare it->object's, and this is
 10697                  unlikely to happen in that case anyway.  */
 10698               if (IT_CHARPOS (*it) == orig_charpos
 10699                   && it->method == orig_method
 10700                   && orig_method == GET_FROM_BUFFER)
 10701                 set_iterator_to_next (it, false);
 10702               it->continuation_lines_width += it->current_x;
 10703             }
 10704           break;
 10705 
 10706         default:
 10707           emacs_abort ();
 10708         }
 10709 
 10710       /* Reset/increment for the next run.  */
 10711       it->current_x = line_start_x;
 10712       line_start_x = 0;
 10713       it->hpos = 0;
 10714       it->line_number_produced_p = false;
 10715       it->current_y += it->max_ascent + it->max_descent;
 10716       ++it->vpos;
 10717       last_height = it->max_ascent + it->max_descent;
 10718       it->max_ascent = it->max_descent = 0;
 10719     }
 10720 
 10721  out:
 10722 
 10723   /* On text terminals, we may stop at the end of a line in the middle
 10724      of a multi-character glyph.  If the glyph itself is continued,
 10725      i.e. it is actually displayed on the next line, don't treat this
 10726      stopping point as valid; move to the next line instead (unless
 10727      that brings us offscreen).  */
 10728   if (!FRAME_WINDOW_P (it->f)
 10729       && op & MOVE_TO_POS
 10730       && IT_CHARPOS (*it) == to_charpos
 10731       && it->what == IT_CHARACTER
 10732       && it->nglyphs > 1
 10733       && it->line_wrap == WINDOW_WRAP
 10734       && it->current_x == it->last_visible_x - 1
 10735       && it->c != '\n'
 10736       && it->c != '\t'
 10737       && it->w->window_end_valid
 10738       && it->vpos < it->w->window_end_vpos)
 10739     {
 10740       it->continuation_lines_width += it->current_x;
 10741       it->current_x = it->hpos = it->max_ascent = it->max_descent = 0;
 10742       it->current_y += it->max_ascent + it->max_descent;
 10743       ++it->vpos;
 10744       last_height = it->max_ascent + it->max_descent;
 10745     }
 10746 
 10747   if (backup_data)
 10748     bidi_unshelve_cache (backup_data, true);
 10749 
 10750   move_trace ("move_it_to: reached %d\n", reached);
 10751 
 10752   return max_current_x;
 10753 }
 10754 
 10755 
 10756 /* Move iterator IT backward by a specified y-distance DY, DY >= 0.
 10757 
 10758    If DY > 0, move IT backward that many pixels.
 10759    DY = 0 means move IT backward to the preceding line start or to BEGV.
 10760    This function may move over less or more than DY pixels if
 10761    IT->current_y - DY ends up in the middle of a line; in this case
 10762    IT->current_y will be set to the top of the line either before or
 10763    after the exact pixel coordinate.  */
 10764 
 10765 void
 10766 move_it_vertically_backward (struct it *it, int dy)
 10767 {
 10768   int nlines, h;
 10769   struct it it2, it3;
 10770   void *it2data = NULL, *it3data = NULL;
 10771   ptrdiff_t start_pos;
 10772   int nchars_per_row
 10773     = (it->last_visible_x - it->first_visible_x) / FRAME_COLUMN_WIDTH (it->f);
 10774   ptrdiff_t pos_limit;
 10775 
 10776  move_further_back:
 10777   eassert (dy >= 0);
 10778 
 10779   start_pos = IT_CHARPOS (*it);
 10780 
 10781   /* Estimate how many newlines we must move back.  */
 10782   nlines = max (1, dy / default_line_pixel_height (it->w));
 10783   if (it->line_wrap == TRUNCATE || nchars_per_row == 0)
 10784     pos_limit = BEGV;
 10785   else
 10786     pos_limit = max (start_pos - nlines * nchars_per_row, BEGV);
 10787 
 10788   /* Set the iterator's position that many lines back.  But don't go
 10789      back more than NLINES full screen lines -- this wins a day with
 10790      buffers which have very long lines.  */
 10791   while (nlines-- && IT_CHARPOS (*it) > pos_limit)
 10792     back_to_previous_visible_line_start (it);
 10793 
 10794   /* Reseat the iterator here.  When moving backward, we don't want
 10795      reseat to skip forward over invisible text, set up the iterator
 10796      to deliver from overlay strings at the new position etc.  So,
 10797      use reseat_1 here.  */
 10798   reseat_1 (it, it->current.pos, true);
 10799 
 10800   /* We are now surely at a line start.  */
 10801   it->current_x = it->hpos = 0; /* FIXME: this is incorrect when bidi
 10802                                    reordering is in effect.  */
 10803   it->continuation_lines_width = 0;
 10804 
 10805   /* Move forward and see what y-distance we moved.  First move to the
 10806      start of the next line so that we get its height.  We need this
 10807      height to be able to tell whether we reached the specified
 10808      y-distance.  */
 10809   SAVE_IT (it2, *it, it2data);
 10810   it2.max_ascent = it2.max_descent = 0;
 10811   do
 10812     {
 10813       move_it_to (&it2, start_pos, -1, -1, it2.vpos + 1,
 10814                   MOVE_TO_POS | MOVE_TO_VPOS);
 10815     }
 10816   while (!(IT_POS_VALID_AFTER_MOVE_P (&it2)
 10817            /* If we are in a display string which starts at START_POS,
 10818               and that display string includes a newline, and we are
 10819               right after that newline (i.e. at the beginning of a
 10820               display line), exit the loop, because otherwise we will
 10821               infloop, since move_it_to will see that it is already at
 10822               START_POS and will not move.  */
 10823            || (it2.method == GET_FROM_STRING
 10824                && IT_CHARPOS (it2) == start_pos
 10825                && SREF (it2.string, IT_STRING_BYTEPOS (it2) - 1) == '\n')));
 10826   eassert (IT_CHARPOS (*it) >= BEGV);
 10827   SAVE_IT (it3, it2, it3data);
 10828 
 10829   move_it_to (&it2, start_pos, -1, -1, -1, MOVE_TO_POS);
 10830   eassert (IT_CHARPOS (*it) >= BEGV);
 10831   /* H is the actual vertical distance from the position in *IT
 10832      and the starting position.  */
 10833   h = it2.current_y - it->current_y;
 10834   /* NLINES is the distance in number of lines.  */
 10835   nlines = it2.vpos - it->vpos;
 10836 
 10837   /* Correct IT's y and vpos position
 10838      so that they are relative to the starting point.  */
 10839   it->vpos -= nlines;
 10840   it->current_y -= h;
 10841 
 10842   if (dy == 0)
 10843     {
 10844       /* DY == 0 means move to the start of the screen line.  The
 10845          value of nlines is > 0 if continuation lines were involved,
 10846          or if the original IT position was at start of a line.  */
 10847       RESTORE_IT (it, it, it2data);
 10848       if (nlines > 0)
 10849         move_it_by_lines (it, nlines);
 10850       /* The above code moves us to some position NLINES down,
 10851          usually to its first glyph (leftmost in an L2R line), but
 10852          that's not necessarily the start of the line, under bidi
 10853          reordering.  We want to get to the character position
 10854          that is immediately after the newline of the previous
 10855          line.  */
 10856       if (it->bidi_p
 10857           && !it->continuation_lines_width
 10858           && !STRINGP (it->string)
 10859           && IT_CHARPOS (*it) > BEGV
 10860           && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
 10861         {
 10862           ptrdiff_t cp = IT_CHARPOS (*it), bp = IT_BYTEPOS (*it);
 10863 
 10864           dec_both (&cp, &bp);
 10865           SET_WITH_NARROWED_BEGV (it, cp,
 10866                                   find_newline_no_quit (cp, bp, -1, NULL),
 10867                                   get_small_narrowing_begv (it->w, IT_CHARPOS (*it)));
 10868           move_it_to (it, cp, -1, -1, -1, MOVE_TO_POS);
 10869         }
 10870       bidi_unshelve_cache (it3data, true);
 10871     }
 10872   else
 10873     {
 10874       /* The y-position we try to reach, relative to *IT.
 10875          Note that H has been subtracted in front of the if-statement.  */
 10876       int target_y = it->current_y + h - dy;
 10877       int y0 = it3.current_y;
 10878       int y1;
 10879       int line_height;
 10880 
 10881       RESTORE_IT (&it3, &it3, it3data);
 10882       y1 = line_bottom_y (&it3);
 10883       line_height = y1 - y0;
 10884       RESTORE_IT (it, it, it2data);
 10885       /* If we did not reach target_y, try to move further backward if
 10886          we can.  If we moved too far backward, try to move forward.  */
 10887       if (target_y < it->current_y
 10888           /* This is heuristic.  In a window that's 3 lines high, with
 10889              a line height of 13 pixels each, recentering with point
 10890              on the bottom line will try to move -39/2 = 19 pixels
 10891              backward.  Try to avoid moving into the first line.  */
 10892           && (it->current_y - target_y
 10893               > min (window_box_height (it->w), line_height * 2 / 3))
 10894           && IT_CHARPOS (*it) > BEGV)
 10895         {
 10896           move_trace ("  not far enough -> move_vert %d\n",
 10897                       target_y - it->current_y);
 10898           dy = it->current_y - target_y;
 10899           goto move_further_back;
 10900         }
 10901       else if (target_y >= it->current_y + line_height
 10902                && IT_CHARPOS (*it) < ZV)
 10903         {
 10904           /* Should move forward by at least one line, maybe more.
 10905 
 10906              Note: Calling move_it_by_lines can be expensive on
 10907              terminal frames, where compute_motion is used (via
 10908              vmotion) to do the job, when there are very long lines
 10909              and truncate-lines is nil.  That's the reason for
 10910              treating terminal frames specially here.  */
 10911 
 10912           if (!FRAME_WINDOW_P (it->f))
 10913             move_it_vertically (it, target_y - it->current_y);
 10914           else
 10915             {
 10916               struct text_pos last_pos;
 10917               int last_y, last_vpos;
 10918               do
 10919                 {
 10920                   last_pos = it->current.pos;
 10921                   last_y = it->current_y;
 10922                   last_vpos = it->vpos;
 10923                   move_it_by_lines (it, 1);
 10924                 }
 10925               while (target_y > it->current_y && IT_CHARPOS (*it) < ZV);
 10926               if (it->current_y > target_y)
 10927                 {
 10928                   reseat (it, last_pos, true);
 10929                   it->current_y = last_y;
 10930                   it->vpos = last_vpos;
 10931                 }
 10932             }
 10933         }
 10934     }
 10935 }
 10936 
 10937 
 10938 /* Move IT by a specified amount of pixel lines DY.  DY negative means
 10939    move backwards.  DY = 0 means move to start of screen line.  At the
 10940    end, IT will be on the start of a screen line.  */
 10941 
 10942 void
 10943 move_it_vertically (struct it *it, int dy)
 10944 {
 10945   if (dy <= 0)
 10946     move_it_vertically_backward (it, -dy);
 10947   else
 10948     {
 10949       move_trace ("move_it_v: from %td, %d\n", IT_CHARPOS (*it), dy);
 10950       move_it_to (it, ZV, -1, it->current_y + dy, -1,
 10951                   MOVE_TO_POS | MOVE_TO_Y);
 10952       move_trace ("move_it_v: to %td\n", IT_CHARPOS (*it));
 10953 
 10954       /* If buffer ends in ZV without a newline, move to the start of
 10955          the line to satisfy the post-condition.  */
 10956       if (IT_CHARPOS (*it) == ZV
 10957           && ZV > BEGV
 10958           && FETCH_BYTE (IT_BYTEPOS (*it) - 1) != '\n')
 10959         move_it_by_lines (it, 0);
 10960     }
 10961 }
 10962 
 10963 
 10964 /* Move iterator IT past the end of the text line it is in.  */
 10965 
 10966 void
 10967 move_it_past_eol (struct it *it)
 10968 {
 10969   enum move_it_result rc;
 10970 
 10971   rc = move_it_in_display_line_to (it, Z, 0, MOVE_TO_POS);
 10972   if (rc == MOVE_NEWLINE_OR_CR)
 10973     set_iterator_to_next (it, false);
 10974 }
 10975 
 10976 
 10977 /* Move IT by a specified number DVPOS of screen lines down.  DVPOS
 10978    negative means move up.  DVPOS == 0 means move to the start of the
 10979    screen line.
 10980 
 10981    Optimization idea: If we would know that IT->f doesn't use
 10982    a face with proportional font, we could be faster for
 10983    truncate-lines nil.  */
 10984 
 10985 void
 10986 move_it_by_lines (struct it *it, ptrdiff_t dvpos)
 10987 {
 10988 
 10989   /* The commented-out optimization uses vmotion on terminals.  This
 10990      gives bad results, because elements like it->what, on which
 10991      callers such as pos_visible_p rely, aren't updated.  */
 10992   /* struct position pos;
 10993     if (!FRAME_WINDOW_P (it->f))
 10994     {
 10995       struct text_pos textpos;
 10996 
 10997       pos = *vmotion (IT_CHARPOS (*it), dvpos, it->w);
 10998       SET_TEXT_POS (textpos, pos.bufpos, pos.bytepos);
 10999       reseat (it, textpos, true);
 11000       it->vpos += pos.vpos;
 11001       it->current_y += pos.vpos;
 11002     }
 11003     else */
 11004 
 11005   if (dvpos == 0)
 11006     {
 11007       /* DVPOS == 0 means move to the start of the screen line.  */
 11008       move_it_vertically_backward (it, 0);
 11009       /* Let next call to line_bottom_y calculate real line height.  */
 11010       last_height = 0;
 11011     }
 11012   else if (dvpos > 0)
 11013     {
 11014       move_it_to (it, -1, -1, -1, it->vpos + dvpos, MOVE_TO_VPOS);
 11015       if (!IT_POS_VALID_AFTER_MOVE_P (it))
 11016         {
 11017           /* Only move to the next buffer position if we ended up in a
 11018              string from display property, not in an overlay string
 11019              (before-string or after-string).  That is because the
 11020              latter don't conceal the underlying buffer position, so
 11021              we can ask to move the iterator to the exact position we
 11022              are interested in.  Note that, even if we are already at
 11023              IT_CHARPOS (*it), the call below is not a no-op, as it
 11024              will detect that we are at the end of the string, pop the
 11025              iterator, and compute it->current_x and it->hpos
 11026              correctly.  */
 11027           move_it_to (it, IT_CHARPOS (*it) + it->string_from_display_prop_p,
 11028                       -1, -1, -1, MOVE_TO_POS);
 11029         }
 11030     }
 11031   else
 11032     {
 11033       struct it it2;
 11034       void *it2data = NULL;
 11035       ptrdiff_t start_charpos, orig_charpos, i;
 11036       int nchars_per_row
 11037         = (it->last_visible_x - it->first_visible_x) / FRAME_COLUMN_WIDTH (it->f);
 11038       bool hit_pos_limit = false;
 11039       ptrdiff_t pos_limit;
 11040 
 11041       /* Start at the beginning of the screen line containing IT's
 11042          position.  This may actually move vertically backwards,
 11043          in case of overlays, so adjust dvpos accordingly.  */
 11044       dvpos += it->vpos;
 11045       orig_charpos = IT_CHARPOS (*it);
 11046       move_it_vertically_backward (it, 0);
 11047       dvpos -= it->vpos;
 11048 
 11049       /* Go back -DVPOS buffer lines, but no farther than -DVPOS full
 11050          screen lines, and reseat the iterator there.  */
 11051       start_charpos = IT_CHARPOS (*it);
 11052       if (it->line_wrap == TRUNCATE || nchars_per_row == 0)
 11053         pos_limit = BEGV;
 11054       else
 11055         pos_limit = max (start_charpos + dvpos * nchars_per_row, BEGV);
 11056 
 11057       for (i = -dvpos; i > 0 && IT_CHARPOS (*it) > pos_limit; --i)
 11058         back_to_previous_visible_line_start (it);
 11059       if (i > 0 && IT_CHARPOS (*it) <= pos_limit)
 11060         hit_pos_limit = true;
 11061       reseat (it, it->current.pos, true);
 11062 
 11063       /* Move further back if we end up in a string or an image.  */
 11064       while (!IT_POS_VALID_AFTER_MOVE_P (it))
 11065         {
 11066           /* First try to move to start of display line.  */
 11067           dvpos += it->vpos;
 11068           move_it_vertically_backward (it, 0);
 11069           dvpos -= it->vpos;
 11070           if (IT_POS_VALID_AFTER_MOVE_P (it))
 11071             break;
 11072           /* If start of line is still in string or image,
 11073              move further back.  */
 11074           back_to_previous_visible_line_start (it);
 11075           reseat (it, it->current.pos, true);
 11076           dvpos--;
 11077         }
 11078 
 11079       it->current_x = it->hpos = 0;
 11080 
 11081       /* Above call may have moved too far if continuation lines
 11082          are involved.  Scan forward and see if it did.  */
 11083       SAVE_IT (it2, *it, it2data);
 11084       it2.vpos = it2.current_y = 0;
 11085       move_it_to (&it2, start_charpos, -1, -1, -1, MOVE_TO_POS);
 11086       it->vpos -= it2.vpos;
 11087       it->current_y -= it2.current_y;
 11088       it->current_x = it->hpos = 0;
 11089 
 11090       /* If we moved too far back, move IT some lines forward.  */
 11091       if (it2.vpos > -dvpos)
 11092         {
 11093           int delta = it2.vpos + dvpos;
 11094 
 11095           RESTORE_IT (&it2, &it2, it2data);
 11096           SAVE_IT (it2, *it, it2data);
 11097           move_it_to (it, -1, -1, -1, it->vpos + delta, MOVE_TO_VPOS);
 11098           /* Move back again if we got too far ahead,
 11099              or didn't move at all.  */
 11100           if (it->vpos - it2.vpos > delta || IT_CHARPOS (*it) == orig_charpos)
 11101             RESTORE_IT (it, &it2, it2data);
 11102           else
 11103             bidi_unshelve_cache (it2data, true);
 11104         }
 11105       else if (hit_pos_limit && pos_limit > BEGV
 11106                && dvpos < 0 && it2.vpos < -dvpos)
 11107         {
 11108           /* If we hit the limit, but still didn't make it far enough
 11109              back, that means there's a display string with a newline
 11110              covering a large chunk of text, and that caused
 11111              back_to_previous_visible_line_start try to go too far.
 11112              Punish those who commit such atrocities by going back
 11113              until we've reached DVPOS, after lifting the limit, which
 11114              could make it slow for very long lines.  "If it hurts,
 11115              don't do that!"  */
 11116           dvpos += it2.vpos;
 11117           RESTORE_IT (it, it, it2data);
 11118           for (i = -dvpos; i > 0; --i)
 11119             {
 11120               back_to_previous_visible_line_start (it);
 11121               it->vpos--;
 11122             }
 11123           reseat_1 (it, it->current.pos, true);
 11124         }
 11125       else
 11126         RESTORE_IT (it, it, it2data);
 11127     }
 11128 }
 11129 
 11130 int
 11131 partial_line_height (struct it *it_origin)
 11132 {
 11133   /* In a buffer with very long and truncated lines, we ignore the
 11134      possibly-partial height of the last line in the window: it is too
 11135      expensive to compute that (since in most cases that involves
 11136      going all the way to ZV), and the effect of ignoring it is
 11137      relatively minor.  */
 11138   if (XBUFFER (it_origin->w->contents)->long_line_optimizations_p
 11139       && it_origin->line_wrap == TRUNCATE)
 11140     return 0;
 11141 
 11142   int partial_height;
 11143   void *it_data = NULL;
 11144   struct it it;
 11145   SAVE_IT (it, *it_origin, it_data);
 11146   move_it_to (&it, ZV, -1, it.last_visible_y, -1,
 11147               MOVE_TO_POS | MOVE_TO_Y);
 11148   if (it.what == IT_EOB)
 11149     {
 11150       int vis_height = it.last_visible_y - it.current_y;
 11151       int height = it.ascent + it.descent;
 11152       partial_height = (vis_height < height) ? vis_height : 0;
 11153     }
 11154   else
 11155     {
 11156       int last_line_y = it.current_y;
 11157       move_it_by_lines (&it, 1);
 11158       partial_height = (it.current_y > it.last_visible_y)
 11159         ? it.last_visible_y - last_line_y : 0;
 11160     }
 11161   RESTORE_IT (&it, &it, it_data);
 11162   return partial_height;
 11163 }
 11164 
 11165 /* Approximate move_it_in_display_line_to for very long and truncated
 11166    display lines, when moving horizontally.  This is used when the
 11167    buffer's long_line_optimizations_p flag is set.  It ignores various
 11168    complications, like different font sizes, invisible text, display
 11169    and overlay strings, and, to some degree, bidirectional text.  So
 11170    caveat emptor!
 11171 
 11172    Starting from IT's position, reseat IT after skipping NCHARS
 11173    characters or to the next newline/ZV, whichever comes first.  Return
 11174    what move_it_in_display_line_to would have returned in this case.  */
 11175 
 11176 static enum move_it_result
 11177 fast_move_it_horizontally (struct it *it, ptrdiff_t nchars)
 11178 {
 11179   ptrdiff_t nl_bytepos;
 11180   ptrdiff_t nl_pos = find_newline_no_quit (IT_CHARPOS (*it), IT_BYTEPOS (*it),
 11181                                            1, &nl_bytepos);
 11182   struct text_pos new_pos;
 11183   enum move_it_result move_result;
 11184 
 11185   if (nl_pos - IT_CHARPOS (*it) > nchars)
 11186     {
 11187       SET_TEXT_POS (new_pos,
 11188                     IT_CHARPOS (*it) + nchars,
 11189                     CHAR_TO_BYTE (IT_CHARPOS (*it) + nchars));
 11190       move_result = MOVE_X_REACHED;
 11191     }
 11192   else
 11193     {
 11194       if (nl_bytepos < ZV_BYTE
 11195           || (nl_bytepos > BEGV_BYTE
 11196               && FETCH_BYTE (nl_bytepos - 1) == '\n'))
 11197         {
 11198           nl_pos--;
 11199           nl_bytepos--;
 11200           move_result = MOVE_NEWLINE_OR_CR;
 11201         }
 11202       else
 11203         move_result = MOVE_POS_MATCH_OR_ZV;
 11204       SET_TEXT_POS (new_pos, nl_pos, nl_bytepos);
 11205     }
 11206   reseat (it, new_pos, false);
 11207   return move_result;
 11208 }
 11209 
 11210 /* Return true if IT points into the middle of a display vector.  */
 11211 
 11212 bool
 11213 in_display_vector_p (struct it *it)
 11214 {
 11215   return (it->method == GET_FROM_DISPLAY_VECTOR
 11216           && it->current.dpvec_index > 0
 11217           && it->dpvec + it->current.dpvec_index != it->dpend);
 11218 }
 11219 
 11220 /* This is like Fwindow_text_pixel_size but assumes that WINDOW's buffer
 11221    is the current buffer.  Fbuffer_text_pixel_size calls it after it has
 11222    set WINDOW's buffer to the buffer specified by its BUFFER_OR_NAME
 11223    argument.  */
 11224 static Lisp_Object
 11225 window_text_pixel_size (Lisp_Object window, Lisp_Object from, Lisp_Object to,
 11226                         Lisp_Object x_limit, Lisp_Object y_limit,
 11227                         Lisp_Object mode_lines, Lisp_Object ignore_line_at_end)
 11228 {
 11229   struct window *w = decode_live_window (window);
 11230   struct it it;
 11231   ptrdiff_t start, end, bpos;
 11232   struct text_pos startp;
 11233   void *itdata = NULL;
 11234   int c, max_x = 0, max_y = 0, x = 0, y = 0, vertical_offset = 0, doff = 0;
 11235 
 11236   if (NILP (from))
 11237     {
 11238       start = BEGV;
 11239       bpos = BEGV_BYTE;
 11240     }
 11241   else if (EQ (from, Qt))
 11242     {
 11243       start = BEGV;
 11244       bpos = BEGV_BYTE;
 11245       while (bpos < ZV_BYTE)
 11246         {
 11247           c = FETCH_BYTE (bpos);
 11248           if (!(c == ' ' || c == '\t' || c == '\n' || c == '\r'))
 11249             break;
 11250           inc_both (&start, &bpos);
 11251         }
 11252       while (bpos > BEGV_BYTE)
 11253         {
 11254           dec_both (&start, &bpos);
 11255           c = FETCH_BYTE (bpos);
 11256           if (!(c == ' ' || c == '\t'))
 11257             break;
 11258         }
 11259     }
 11260   else if (CONSP (from))
 11261     {
 11262       start = clip_to_bounds (BEGV, fix_position (XCAR (from)), ZV);
 11263       bpos = CHAR_TO_BYTE (start);
 11264       CHECK_FIXNUM (XCDR (from));
 11265       vertical_offset = XFIXNUM (XCDR (from));
 11266     }
 11267   else
 11268     {
 11269       start = clip_to_bounds (BEGV, fix_position (from), ZV);
 11270       bpos = CHAR_TO_BYTE (start);
 11271     }
 11272 
 11273   SET_TEXT_POS (startp, start, bpos);
 11274 
 11275   if (NILP (to))
 11276     end = ZV;
 11277   else if (EQ (to, Qt))
 11278     {
 11279       end = ZV;
 11280       bpos = ZV_BYTE;
 11281       while (bpos > BEGV_BYTE)
 11282         {
 11283           dec_both (&end, &bpos);
 11284           c = FETCH_BYTE (bpos);
 11285           if (!(c == ' ' || c == '\t' || c == '\n' || c == '\r'))
 11286             {
 11287               inc_both (&end, &bpos);
 11288               break;
 11289             }
 11290         }
 11291       while (bpos < ZV_BYTE)
 11292         {
 11293           c = fetch_char_advance (&end, &bpos);
 11294           if (!(c == ' ' || c == '\t'))
 11295             break;
 11296         }
 11297     }
 11298   else
 11299     end = clip_to_bounds (start, fix_position (to), ZV);
 11300 
 11301   if (RANGED_FIXNUMP (0, x_limit, INT_MAX))
 11302     max_x = XFIXNUM (x_limit);
 11303   else if (!NILP (x_limit))
 11304     max_x = INT_MAX;
 11305 
 11306   if (NILP (y_limit))
 11307     max_y = INT_MAX;
 11308   else if (RANGED_FIXNUMP (0, y_limit, INT_MAX))
 11309     max_y = XFIXNUM (y_limit);
 11310 
 11311   itdata = bidi_shelve_cache ();
 11312 
 11313   start_display (&it, w, startp);
 11314 
 11315   int start_y = it.current_y;
 11316 
 11317   /* It makes no sense to measure dimensions of region of text that
 11318      crosses the point where bidi reordering changes scan direction.
 11319      By using unidirectional movement here we at least support the use
 11320      case of measuring regions of text that have a uniformly R2L
 11321      directionality, and regions that begin and end in text of the
 11322      same directionality.  */
 11323   it.bidi_p = false;
 11324 
 11325   int start_x;
 11326   if (vertical_offset != 0)
 11327     {
 11328       int last_y;
 11329       it.current_y = 0;
 11330 
 11331       move_it_by_lines (&it, 0);
 11332 
 11333       /* `move_it_vertically_backward' is called by move_it_vertically
 11334          to move by a negative value (upwards), but it is not always
 11335          guaranteed to leave the iterator at or above the position
 11336          given by the offset, which this loop ensures.  */
 11337       if (vertical_offset < 0)
 11338         {
 11339           while (it.current_y > vertical_offset)
 11340             {
 11341               last_y = it.current_y;
 11342               move_it_vertically_backward (&it,
 11343                                            (abs (vertical_offset)
 11344                                             + it.current_y));
 11345 
 11346               if (it.current_y == last_y)
 11347                 break;
 11348             }
 11349         }
 11350       else
 11351         {
 11352           move_it_vertically (&it, vertical_offset);
 11353         }
 11354 
 11355       it.current_y = (WINDOW_TAB_LINE_HEIGHT (w)
 11356                       + WINDOW_HEADER_LINE_HEIGHT (w));
 11357       start = clip_to_bounds (BEGV, IT_CHARPOS (it), ZV);
 11358       start_y = it.current_y;
 11359       start_x = it.current_x;
 11360     }
 11361   else
 11362     {
 11363       /* Start at the beginning of the line containing FROM.  Otherwise
 11364          IT.current_x will be incorrectly set to zero at some arbitrary
 11365          non-zero X coordinate.  */
 11366       reseat_at_previous_visible_line_start (&it);
 11367       it.current_x = it.hpos = 0;
 11368       if (IT_CHARPOS (it) != start)
 11369         {
 11370           void *it1data = NULL;
 11371           struct it it1;
 11372 
 11373           SAVE_IT (it1, it, it1data);
 11374           move_it_to (&it, start, -1, -1, -1, MOVE_TO_POS);
 11375           /* We could have a display property at START, in which case
 11376              asking move_it_to to stop at START will overshoot and
 11377              stop at position after START.  So we try again, stopping
 11378              before START, and account for the width of the last
 11379              buffer position manually.  */
 11380           if (IT_CHARPOS (it) > start && start > BEGV)
 11381             {
 11382               ptrdiff_t it1pos = IT_CHARPOS (it1);
 11383               int it1_x = it1.current_x;
 11384 
 11385               RESTORE_IT (&it, &it1, it1data);
 11386               /* If START - 1 is the beginning of screen line,
 11387                  move_it_to will not move, so we need to use a
 11388                  lower-level move_it_in_display_line subroutine, and
 11389                  tell it to move just 1 pixel, so it stops at the next
 11390                  display element.  */
 11391               if (start - 1 > it1pos)
 11392                 move_it_to (&it, start - 1, -1, -1, -1, MOVE_TO_POS);
 11393               else
 11394                 move_it_in_display_line (&it, start, it1_x + 1,
 11395                                          MOVE_TO_POS | MOVE_TO_X);
 11396               move_it_to (&it, start - 1, -1, -1, -1, MOVE_TO_POS);
 11397               start_x = it.current_x;
 11398               /* If we didn't change our buffer position, the pixel
 11399                  width of what's here was not yet accounted for; do it
 11400                  manually.  */
 11401               if (IT_CHARPOS (it) == start - 1)
 11402                 start_x += it.pixel_width;
 11403             }
 11404           else
 11405             {
 11406               start_x = it.current_x;
 11407               bidi_unshelve_cache (it1data, true);
 11408             }
 11409         }
 11410       else
 11411         start_x = it.current_x;
 11412     }
 11413 
 11414   /* Now move to TO.  */
 11415   int move_op = MOVE_TO_POS | MOVE_TO_Y;
 11416   int to_x = -1;
 11417   it.current_y = start_y;
 11418   /* If FROM is on a newline, pretend that we start at the beginning
 11419      of the next line, because the newline takes no place on display.  */
 11420   if (FETCH_BYTE (start) == '\n')
 11421     it.current_x = 0;
 11422   if (!NILP (x_limit))
 11423     {
 11424       it.last_visible_x = max_x;
 11425       /* Actually, we never want move_it_to stop at to_x.  But to make
 11426          sure that move_it_in_display_line_to always moves far enough,
 11427          we set to_x to INT_MAX and specify MOVE_TO_X.  */
 11428       move_op |= MOVE_TO_X;
 11429       to_x = INT_MAX;
 11430     }
 11431 
 11432   void *it2data = NULL;
 11433   struct it it2;
 11434   SAVE_IT (it2, it, it2data);
 11435 
 11436   x = move_it_to (&it, end, to_x, max_y, -1, move_op);
 11437 
 11438   /* We could have a display property at END, in which case asking
 11439      move_it_to to stop at END will overshoot and stop at position
 11440      after END.  So we try again, stopping before END, and account for
 11441      the width of the last buffer position manually.  */
 11442   if (IT_CHARPOS (it) > end)
 11443     {
 11444       end--;
 11445       RESTORE_IT (&it, &it2, it2data);
 11446       x = move_it_to (&it, end, to_x, max_y, -1, move_op);
 11447       /* Add the width of the thing at TO, but only if we didn't
 11448          overshoot it; if we did, it is already accounted for.  Also,
 11449          account for the height of the thing at TO.  */
 11450       if (IT_CHARPOS (it) == end)
 11451         {
 11452           x += it.pixel_width;
 11453 
 11454           /* DTRT if ignore_line_at_end is t.  */
 11455           if (!NILP (ignore_line_at_end))
 11456             doff = (max (it.max_ascent, it.ascent)
 11457                     + max (it.max_descent, it.descent));
 11458           else
 11459             {
 11460               it.max_ascent = max (it.max_ascent, it.ascent);
 11461               it.max_descent = max (it.max_descent, it.descent);
 11462             }
 11463         }
 11464     }
 11465   else
 11466     bidi_unshelve_cache (it2data, true);
 11467 
 11468   if (!NILP (x_limit))
 11469     {
 11470       /* Don't return more than X-LIMIT.  */
 11471       if (x > max_x)
 11472         x = max_x;
 11473     }
 11474 
 11475   /* If text spans more than one screen line, we don't need to adjust
 11476      the x-span for start_x, since the second and subsequent lines
 11477      will begin at zero X coordinate.  */
 11478   if (it.current_y > start_y)
 11479     start_x = 0;
 11480 
 11481   /* Subtract height of header-line and tab-line which was counted
 11482      automatically by start_display.  */
 11483   if (!NILP (ignore_line_at_end))
 11484     y = (it.current_y + doff
 11485          - WINDOW_TAB_LINE_HEIGHT (w)
 11486          - WINDOW_HEADER_LINE_HEIGHT (w));
 11487   else
 11488     y = (it.current_y + it.max_ascent + it.max_descent + doff
 11489          - WINDOW_TAB_LINE_HEIGHT (w) - WINDOW_HEADER_LINE_HEIGHT (w));
 11490 
 11491   /* Don't return more than Y-LIMIT.  */
 11492   if (y > max_y)
 11493     y = max_y;
 11494 
 11495   if ((EQ (mode_lines, Qtab_line) || EQ (mode_lines, Qt))
 11496       && window_wants_tab_line (w))
 11497     /* Add height of tab-line as requested.  */
 11498     {
 11499       Lisp_Object window_tab_line_format
 11500         = window_parameter (w, Qtab_line_format);
 11501 
 11502       y = y + display_mode_line (w, TAB_LINE_FACE_ID,
 11503                                  NILP (window_tab_line_format)
 11504                                  ? BVAR (current_buffer, tab_line_format)
 11505                                  : window_tab_line_format);
 11506     }
 11507 
 11508   if ((EQ (mode_lines, Qheader_line) || EQ (mode_lines, Qt))
 11509       && window_wants_header_line (w))
 11510     {
 11511       Lisp_Object window_header_line_format
 11512         = window_parameter (w, Qheader_line_format);
 11513 
 11514       y = y + display_mode_line (w, HEADER_LINE_FACE_ID,
 11515                                  NILP (window_header_line_format)
 11516                                  ? BVAR (current_buffer, header_line_format)
 11517                                  : window_header_line_format);
 11518     }
 11519 
 11520   if ((EQ (mode_lines, Qmode_line) || EQ (mode_lines, Qt))
 11521       && window_wants_mode_line (w))
 11522     {
 11523       Lisp_Object window_mode_line_format
 11524         = window_parameter (w, Qmode_line_format);
 11525 
 11526       y = y + display_mode_line (w, CURRENT_MODE_LINE_ACTIVE_FACE_ID (w),
 11527                                  NILP (window_mode_line_format)
 11528                                  ? BVAR (current_buffer, mode_line_format)
 11529                                  : window_mode_line_format);
 11530     }
 11531 
 11532   bidi_unshelve_cache (itdata, false);
 11533 
 11534   return (!vertical_offset
 11535           ? Fcons (make_fixnum (x - start_x), make_fixnum (y))
 11536           : list3i (x - start_x, y, start));
 11537 }
 11538 
 11539 DEFUN ("window-text-pixel-size", Fwindow_text_pixel_size, Swindow_text_pixel_size, 0, 7, 0,
 11540        doc: /* Return the size of the text of WINDOW's buffer in pixels.
 11541 WINDOW must be a live window and defaults to the selected one.  The
 11542 return value is a cons of the maximum pixel-width of any text line and
 11543 the pixel-height of all the text lines in the accessible portion of
 11544 buffer text.
 11545 
 11546 If FROM is a cons cell, the return value includes, in addition to the
 11547 dimensions, also a third element that provides the buffer position
 11548 from which measuring of the text dimensions was actually started.
 11549 
 11550 This function exists to allow Lisp programs to adjust the dimensions
 11551 of WINDOW to the buffer text it needs to display.
 11552 
 11553 The optional argument FROM, if non-nil, specifies the first text
 11554 position to consider, and defaults to the minimum accessible position
 11555 of the buffer.  If FROM is a cons, its car specifies a buffer
 11556 position, and its cdr specifies the vertical offset in pixels from
 11557 that position to the first screen line to be measured.  If FROM is t,
 11558 it stands for the minimum accessible position that starts a non-empty
 11559 line.  TO, if non-nil, specifies the last text position and defaults
 11560 to the maximum accessible position of the buffer.  If TO is t, it
 11561 stands for the maximum accessible position that ends a non-empty line.
 11562 
 11563 The optional argument X-LIMIT, if non-nil, specifies the maximum X
 11564 coordinate beyond which the text should be ignored.  It is therefore
 11565 also the maximum width that the function can return.  X-LIMIT nil or
 11566 omitted means to use the pixel-width of WINDOW's body.  This default
 11567 means text of truncated lines wider than the window will be ignored;
 11568 specify a non-nil value for X-LIMIT if lines are truncated and you need
 11569 to account for the truncated text.
 11570 
 11571 Use nil for X-LIMIT if you want to know how high WINDOW should become in
 11572 order to fit all of its buffer's text with the width of WINDOW
 11573 unaltered.  Use the maximum width WINDOW may assume if you intend to
 11574 change WINDOW's width.  Use t for the maximum possible value.  Since
 11575 calculating the width of long lines can take some time, it's always a
 11576 good idea to make this argument as small as possible; in particular, if
 11577 the buffer contains long lines that shall be truncated anyway.
 11578 
 11579 The optional argument Y-LIMIT, if non-nil, specifies the maximum Y
 11580 coordinate beyond which the text is to be ignored; it is therefore
 11581 also the maximum height that the function can return (excluding the
 11582 height of the mode- or header-line, if any).  Y-LIMIT nil or omitted
 11583 means consider all of the accessible portion of buffer text up to the
 11584 position specified by TO.  Since calculating the text height of a
 11585 large buffer can take some time, it makes sense to specify this
 11586 argument if the size of the buffer is large or unknown.
 11587 
 11588 Optional argument MODE-LINES nil or omitted means do not include the
 11589 height of the mode-, tab- or header-line of WINDOW in the return value.
 11590 If it is the symbol `mode-line', `tab-line' or `header-line', include
 11591 only the height of that line, if present, in the return value.  If t,
 11592 include the height of any of these, if present, in the return value.
 11593 
 11594 IGNORE-LINE-AT-END, if non-nil, means to not add the height of the
 11595 screen line that includes TO to the returned height of the text.  */)
 11596   (Lisp_Object window, Lisp_Object from, Lisp_Object to, Lisp_Object x_limit,
 11597    Lisp_Object y_limit, Lisp_Object mode_lines, Lisp_Object ignore_line_at_end)
 11598 {
 11599   struct window *w = decode_live_window (window);
 11600   struct buffer *b = XBUFFER (w->contents);
 11601   struct buffer *old_b = NULL;
 11602   Lisp_Object value;
 11603 
 11604   if (b != current_buffer)
 11605     {
 11606       old_b = current_buffer;
 11607       set_buffer_internal_1 (b);
 11608     }
 11609 
 11610   value = window_text_pixel_size (window, from, to, x_limit, y_limit, mode_lines,
 11611                                   ignore_line_at_end);
 11612 
 11613   if (old_b)
 11614     set_buffer_internal_1 (old_b);
 11615 
 11616   return value;
 11617 }
 11618 
 11619 DEFUN ("buffer-text-pixel-size", Fbuffer_text_pixel_size, Sbuffer_text_pixel_size, 0, 4, 0,
 11620        doc: /* Return size of whole text of BUFFER-OR-NAME in WINDOW.
 11621 BUFFER-OR-NAME must specify a live buffer or the name of a live buffer
 11622 and defaults to the current buffer.  WINDOW must be a live window and
 11623 defaults to the selected one.  The return value is a cons of the maximum
 11624 pixel-width of any text line and the pixel-height of all the text lines
 11625 of the buffer specified by BUFFER-OR-NAME.
 11626 
 11627 The optional arguments X-LIMIT and Y-LIMIT have the same meaning as with
 11628 `window-text-pixel-size'.
 11629 
 11630 Do not use this function if the buffer specified by BUFFER-OR-NAME is
 11631 already displayed in WINDOW.  `window-text-pixel-size' is cheaper in
 11632 that case because it does not have to temporarily show that buffer in
 11633 WINDOW.  */)
 11634   (Lisp_Object buffer_or_name, Lisp_Object window, Lisp_Object x_limit,
 11635    Lisp_Object y_limit)
 11636 {
 11637   struct window *w = decode_live_window (window);
 11638   struct buffer *b = (NILP (buffer_or_name)
 11639                       ? current_buffer
 11640                       : XBUFFER (Fget_buffer (buffer_or_name)));
 11641   Lisp_Object buffer, value;
 11642   specpdl_ref count = SPECPDL_INDEX ();
 11643 
 11644   XSETBUFFER (buffer, b);
 11645 
 11646   /* The unwind form of with_echo_area_buffer is what we need here to
 11647      make WINDOW temporarily show our buffer.  */
 11648   /* FIXME: Can we move this into the `if (!EQ (buffer, w->contents))`?  */
 11649   record_unwind_protect (unwind_with_echo_area_buffer,
 11650                          with_echo_area_buffer_unwind_data (w));
 11651 
 11652   set_buffer_internal_1 (b);
 11653 
 11654   if (!EQ (buffer, w->contents))
 11655     {
 11656       wset_buffer (w, buffer);
 11657       set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
 11658       set_marker_both (w->old_pointm, buffer, BEG, BEG_BYTE);
 11659     }
 11660 
 11661   value = window_text_pixel_size (window, Qnil, Qnil, x_limit, y_limit, Qnil,
 11662                                   Qnil);
 11663 
 11664   unbind_to (count, Qnil);
 11665 
 11666   return value;
 11667 }
 11668 
 11669 
 11670 DEFUN ("display--line-is-continued-p", Fdisplay__line_is_continued_p,
 11671        Sdisplay__line_is_continued_p, 0, 0, 0,
 11672        doc: /* Return non-nil if the current screen line is continued on display.  */)
 11673   (void)
 11674 {
 11675   struct buffer *oldb = current_buffer;
 11676   struct window *w = XWINDOW (selected_window);
 11677   enum move_it_result rc = MOVE_POS_MATCH_OR_ZV;
 11678 
 11679   set_buffer_internal_1 (XBUFFER (w->contents));
 11680 
 11681   if (PT < ZV)
 11682     {
 11683       struct text_pos startpos;
 11684       struct it it;
 11685       void *itdata;
 11686       /* Use a marker, since vertical-motion enters redisplay, which can
 11687          trigger fontifications, which in turn could modify buffer text.  */
 11688       Lisp_Object opoint = Fpoint_marker ();
 11689 
 11690       /* Make sure to start from the beginning of the current screen
 11691          line, so that move_it_in_display_line_to counts pixels correctly.  */
 11692       Fvertical_motion (make_fixnum (0), selected_window, Qnil);
 11693       SET_TEXT_POS (startpos, PT, PT_BYTE);
 11694       itdata = bidi_shelve_cache ();
 11695       start_display (&it, w, startpos);
 11696       /* If lines are truncated, no line is continued.  */
 11697       if (it.line_wrap != TRUNCATE)
 11698         {
 11699           it.glyph_row = NULL;
 11700           rc = move_it_in_display_line_to (&it, ZV, -1, MOVE_TO_POS);
 11701         }
 11702       SET_PT_BOTH (marker_position (opoint), marker_byte_position (opoint));
 11703       bidi_unshelve_cache (itdata, false);
 11704     }
 11705   set_buffer_internal_1 (oldb);
 11706 
 11707   return rc == MOVE_LINE_CONTINUED ? Qt : Qnil;
 11708 }
 11709 
 11710 
 11711 /***********************************************************************
 11712                                Messages
 11713  ***********************************************************************/
 11714 
 11715 /* Return the number of arguments the format string FORMAT needs.  */
 11716 
 11717 static ptrdiff_t
 11718 format_nargs (char const *format)
 11719 {
 11720   ptrdiff_t nargs = 0;
 11721   for (char const *p = format; (p = strchr (p, '%')); p++)
 11722     if (p[1] == '%')
 11723       p++;
 11724     else
 11725       nargs++;
 11726   return nargs;
 11727 }
 11728 
 11729 /* Add a message with format string FORMAT and formatted arguments
 11730    to *Messages*.  */
 11731 
 11732 void
 11733 add_to_log (const char *format, ...)
 11734 {
 11735   va_list ap;
 11736   va_start (ap, format);
 11737   vadd_to_log (format, ap);
 11738   va_end (ap);
 11739 }
 11740 
 11741 void
 11742 vadd_to_log (char const *format, va_list ap)
 11743 {
 11744   ptrdiff_t form_nargs = format_nargs (format);
 11745   ptrdiff_t nargs = 1 + form_nargs;
 11746   Lisp_Object args[10];
 11747   eassert (nargs <= ARRAYELTS (args));
 11748   AUTO_STRING (args0, format);
 11749   args[0] = args0;
 11750   for (ptrdiff_t i = 1; i <= nargs; i++)
 11751     args[i] = va_arg (ap, Lisp_Object);
 11752   Lisp_Object msg = Qnil;
 11753   msg = Fformat_message (nargs, args);
 11754 
 11755   ptrdiff_t len = SBYTES (msg) + 1;
 11756   USE_SAFE_ALLOCA;
 11757   char *buffer = SAFE_ALLOCA (len);
 11758   memcpy (buffer, SDATA (msg), len);
 11759 
 11760   message_dolog (buffer, len - 1, true, STRING_MULTIBYTE (msg));
 11761   SAFE_FREE ();
 11762 }
 11763 
 11764 
 11765 /* Output a newline in the *Messages* buffer if "needs" one.  */
 11766 
 11767 void
 11768 message_log_maybe_newline (void)
 11769 {
 11770   if (message_log_need_newline)
 11771     message_dolog ("", 0, true, false);
 11772 }
 11773 
 11774 
 11775 /* Add a string M of length NBYTES to the message log, optionally
 11776    terminated with a newline when NLFLAG is true.  MULTIBYTE, if
 11777    true, means interpret the contents of M as multibyte.  This
 11778    function calls low-level routines in order to bypass text property
 11779    hooks, etc. which might not be safe to run.
 11780 
 11781    This may GC (insert may run before/after change hooks),
 11782    so the buffer M must NOT point to a Lisp string.  */
 11783 
 11784 void
 11785 message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
 11786 {
 11787   const unsigned char *msg = (const unsigned char *) m;
 11788 
 11789   if (!NILP (Vmemory_full))
 11790     return;
 11791 
 11792   if (!NILP (Vmessage_log_max))
 11793     {
 11794       struct buffer *oldbuf;
 11795       Lisp_Object oldpoint, oldbegv, oldzv;
 11796       int old_windows_or_buffers_changed = windows_or_buffers_changed;
 11797       ptrdiff_t point_at_end = 0;
 11798       ptrdiff_t zv_at_end = 0;
 11799       Lisp_Object old_deactivate_mark;
 11800 
 11801       old_deactivate_mark = Vdeactivate_mark;
 11802       oldbuf = current_buffer;
 11803 
 11804       /* Sanity check, in case the variable has been set to something
 11805          invalid.  */
 11806       if (! STRINGP (Vmessages_buffer_name))
 11807         Vmessages_buffer_name = build_string ("*Messages*");
 11808       /* Ensure the Messages buffer exists, and switch to it.
 11809          If we created it, set the major-mode.  */
 11810       bool newbuffer = NILP (Fget_buffer (Vmessages_buffer_name));
 11811       Fset_buffer (Fget_buffer_create (Vmessages_buffer_name, Qnil));
 11812       if (newbuffer
 11813           && !NILP (Ffboundp (intern ("messages-buffer-mode"))))
 11814         call0 (intern ("messages-buffer-mode"));
 11815 
 11816       bset_undo_list (current_buffer, Qt);
 11817       bset_cache_long_scans (current_buffer, Qnil);
 11818 
 11819       oldpoint = message_dolog_marker1;
 11820       set_marker_restricted_both (oldpoint, Qnil, PT, PT_BYTE);
 11821       oldbegv = message_dolog_marker2;
 11822       set_marker_restricted_both (oldbegv, Qnil, BEGV, BEGV_BYTE);
 11823       oldzv = message_dolog_marker3;
 11824       set_marker_restricted_both (oldzv, Qnil, ZV, ZV_BYTE);
 11825 
 11826       if (PT == Z)
 11827         point_at_end = 1;
 11828       if (ZV == Z)
 11829         zv_at_end = 1;
 11830 
 11831       BEGV = BEG;
 11832       BEGV_BYTE = BEG_BYTE;
 11833       ZV = Z;
 11834       ZV_BYTE = Z_BYTE;
 11835       TEMP_SET_PT_BOTH (Z, Z_BYTE);
 11836 
 11837       /* Insert the string--maybe converting multibyte to single byte
 11838          or vice versa, so that all the text fits the buffer.  */
 11839       if (multibyte
 11840           && NILP (BVAR (current_buffer, enable_multibyte_characters)))
 11841         {
 11842           /* Convert a multibyte string to single-byte
 11843              for the *Message* buffer.  */
 11844           for (ptrdiff_t i = 0; i < nbytes; )
 11845             {
 11846               int char_bytes, c = check_char_and_length (msg + i, &char_bytes);
 11847               char work = CHAR_TO_BYTE8 (c);
 11848               insert_1_both (&work, 1, 1, true, false, false);
 11849               i += char_bytes;
 11850             }
 11851         }
 11852       else if (! multibyte
 11853                && ! NILP (BVAR (current_buffer, enable_multibyte_characters)))
 11854         {
 11855           /* Convert a single-byte string to multibyte
 11856              for the *Message* buffer.  */
 11857           for (ptrdiff_t i = 0; i < nbytes; i++)
 11858             {
 11859               int c = make_char_multibyte (msg[i]);
 11860               unsigned char str[MAX_MULTIBYTE_LENGTH];
 11861               int char_bytes = CHAR_STRING (c, str);
 11862               insert_1_both ((char *) str, 1, char_bytes, true, false, false);
 11863             }
 11864         }
 11865       else if (nbytes)
 11866         insert_1_both (m, chars_in_text (msg, nbytes), nbytes,
 11867                        true, false, false);
 11868 
 11869       if (nlflag)
 11870         {
 11871           ptrdiff_t this_bol, this_bol_byte, prev_bol, prev_bol_byte;
 11872           intmax_t dups;
 11873 
 11874           /* Since we call del_range_both passing false for PREPARE,
 11875              we aren't prepared to run modification hooks (we could
 11876              end up calling modification hooks from another buffer and
 11877              only with AFTER=t, Bug#21824).  */
 11878           specpdl_ref count = SPECPDL_INDEX ();
 11879           specbind (Qinhibit_modification_hooks, Qt);
 11880 
 11881           insert_1_both ("\n", 1, 1, true, false, false);
 11882 
 11883           scan_newline (Z, Z_BYTE, BEG, BEG_BYTE, -2, false);
 11884           this_bol = PT;
 11885           this_bol_byte = PT_BYTE;
 11886 
 11887           /* See if this line duplicates the previous one.
 11888              If so, combine duplicates.  */
 11889           if (this_bol > BEG)
 11890             {
 11891               scan_newline (PT, PT_BYTE, BEG, BEG_BYTE, -2, false);
 11892               prev_bol = PT;
 11893               prev_bol_byte = PT_BYTE;
 11894 
 11895               dups = message_log_check_duplicate (prev_bol_byte,
 11896                                                   this_bol_byte);
 11897               if (dups)
 11898                 {
 11899                   del_range_both (prev_bol, prev_bol_byte,
 11900                                   this_bol, this_bol_byte, false);
 11901                   if (dups > 1)
 11902                     {
 11903                       char dupstr[sizeof " [ times]"
 11904                                   + INT_STRLEN_BOUND (dups)];
 11905 
 11906                       /* If you change this format, don't forget to also
 11907                          change message_log_check_duplicate.  */
 11908                       int duplen = sprintf (dupstr, " [%"PRIdMAX" times]",
 11909                                             dups);
 11910                       TEMP_SET_PT_BOTH (Z - 1, Z_BYTE - 1);
 11911                       insert_1_both (dupstr, duplen, duplen,
 11912                                      true, false, true);
 11913                     }
 11914                 }
 11915             }
 11916 
 11917           /* If we have more than the desired maximum number of lines
 11918              in the *Messages* buffer now, delete the oldest ones.
 11919              This is safe because we don't have undo in this buffer.  */
 11920 
 11921           if (FIXNATP (Vmessage_log_max))
 11922             {
 11923               scan_newline (Z, Z_BYTE, BEG, BEG_BYTE,
 11924                             -XFIXNAT (Vmessage_log_max) - 1, false);
 11925               del_range_both (BEG, BEG_BYTE, PT, PT_BYTE, false);
 11926             }
 11927 
 11928           unbind_to (count, Qnil);
 11929         }
 11930       BEGV = marker_position (oldbegv);
 11931       BEGV_BYTE = marker_byte_position (oldbegv);
 11932 
 11933       if (zv_at_end)
 11934         {
 11935           ZV = Z;
 11936           ZV_BYTE = Z_BYTE;
 11937         }
 11938       else
 11939         {
 11940           ZV = marker_position (oldzv);
 11941           ZV_BYTE = marker_byte_position (oldzv);
 11942         }
 11943 
 11944       if (point_at_end)
 11945         TEMP_SET_PT_BOTH (Z, Z_BYTE);
 11946       else
 11947         /* We can't do Fgoto_char (oldpoint) because it will run some
 11948            Lisp code.  */
 11949         TEMP_SET_PT_BOTH (marker_position (oldpoint),
 11950                           marker_byte_position (oldpoint));
 11951 
 11952       unchain_marker (XMARKER (oldpoint));
 11953       unchain_marker (XMARKER (oldbegv));
 11954       unchain_marker (XMARKER (oldzv));
 11955 
 11956       /* We called insert_1_both above with its 5th argument (PREPARE)
 11957          false, which prevents insert_1_both from calling
 11958          prepare_to_modify_buffer, which in turns prevents us from
 11959          incrementing windows_or_buffers_changed even if *Messages* is
 11960          shown in some window.  So we must manually set
 11961          windows_or_buffers_changed here to make up for that.  */
 11962       windows_or_buffers_changed = old_windows_or_buffers_changed;
 11963       bset_redisplay (current_buffer);
 11964 
 11965       set_buffer_internal (oldbuf);
 11966 
 11967       message_log_need_newline = !nlflag;
 11968       Vdeactivate_mark = old_deactivate_mark;
 11969     }
 11970 }
 11971 
 11972 
 11973 /* We are at the end of the buffer after just having inserted a newline.
 11974    (Note: We depend on the fact we won't be crossing the gap.)
 11975    Check to see if the most recent message looks a lot like the previous one.
 11976    Return 0 if different, 1 if the new one should just replace it, or a
 11977    value N > 1 if we should also append " [N times]".  */
 11978 
 11979 static intmax_t
 11980 message_log_check_duplicate (ptrdiff_t prev_bol_byte, ptrdiff_t this_bol_byte)
 11981 {
 11982   ptrdiff_t i;
 11983   ptrdiff_t len = Z_BYTE - 1 - this_bol_byte;
 11984   bool seen_dots = false;
 11985   unsigned char *p1 = BUF_BYTE_ADDRESS (current_buffer, prev_bol_byte);
 11986   unsigned char *p2 = BUF_BYTE_ADDRESS (current_buffer, this_bol_byte);
 11987 
 11988   for (i = 0; i < len; i++)
 11989     {
 11990       if (i >= 3 && p1[i - 3] == '.' && p1[i - 2] == '.' && p1[i - 1] == '.')
 11991         seen_dots = true;
 11992       if (p1[i] != p2[i])
 11993         return seen_dots;
 11994     }
 11995   p1 += len;
 11996   if (*p1 == '\n')
 11997     return 2;
 11998   if (*p1++ == ' ' && *p1++ == '[')
 11999     {
 12000       char *pend;
 12001       intmax_t n = strtoimax ((char *) p1, &pend, 10);
 12002       if (0 < n && n < INTMAX_MAX && strncmp (pend, " times]\n", 8) == 0)
 12003         return n + 1;
 12004     }
 12005   return 0;
 12006 }
 12007 
 12008 
 12009 /* Display an echo area message M with a specified length of NBYTES
 12010    bytes.  The string may include null characters.  If M is not a
 12011    string, clear out any existing message, and let the mini-buffer
 12012    text show through.
 12013 
 12014    This function cancels echoing.  */
 12015 
 12016 void
 12017 message3 (Lisp_Object m)
 12018 {
 12019   clear_message (true, true);
 12020   cancel_echoing ();
 12021 
 12022   /* First flush out any partial line written with print.  */
 12023   message_log_maybe_newline ();
 12024   if (STRINGP (m))
 12025     {
 12026       ptrdiff_t nbytes = SBYTES (m);
 12027       bool multibyte = STRING_MULTIBYTE (m);
 12028       char *buffer;
 12029       USE_SAFE_ALLOCA;
 12030       SAFE_ALLOCA_STRING (buffer, m);
 12031       message_dolog (buffer, nbytes, true, multibyte);
 12032       SAFE_FREE ();
 12033     }
 12034   if (! inhibit_message)
 12035     message3_nolog (m);
 12036 }
 12037 
 12038 /* Log the message M to stderr.  Log an empty line if M is not a string.  */
 12039 
 12040 static void
 12041 message_to_stderr (Lisp_Object m)
 12042 {
 12043   if (noninteractive_need_newline)
 12044     {
 12045       noninteractive_need_newline = false;
 12046       errputc ('\n');
 12047     }
 12048   if (STRINGP (m))
 12049     {
 12050       Lisp_Object coding_system = Vlocale_coding_system;
 12051       Lisp_Object s;
 12052 
 12053       if (!NILP (Vcoding_system_for_write))
 12054         coding_system = Vcoding_system_for_write;
 12055       if (!NILP (coding_system))
 12056         s = code_convert_string_norecord (m, coding_system, true);
 12057       else
 12058         s = m;
 12059 
 12060       errwrite (SDATA (s), SBYTES (s));
 12061     }
 12062   if (STRINGP (m) || !cursor_in_echo_area)
 12063     errputc ('\n');
 12064 }
 12065 
 12066 /* The non-logging version of message3.
 12067    This does not cancel echoing, because it is used for echoing.
 12068    Perhaps we need to make a separate function for echoing
 12069    and make this cancel echoing.  */
 12070 
 12071 void
 12072 message3_nolog (Lisp_Object m)
 12073 {
 12074   struct frame *sf = SELECTED_FRAME ();
 12075 
 12076   if (FRAME_INITIAL_P (sf))
 12077     message_to_stderr (m);
 12078   /* Error messages get reported properly by cmd_error, so this must be just an
 12079      informative message; if the frame hasn't really been initialized yet, just
 12080      toss it.  */
 12081   else if (INTERACTIVE && sf->glyphs_initialized_p)
 12082     {
 12083       /* Get the frame containing the mini-buffer
 12084          that the selected frame is using.  */
 12085       Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
 12086       Lisp_Object frame = XWINDOW (mini_window)->frame;
 12087       struct frame *f = XFRAME (frame);
 12088 
 12089       if (FRAME_VISIBLE_P (sf) && !FRAME_VISIBLE_P (f))
 12090         Fmake_frame_visible (frame);
 12091 
 12092       if (STRINGP (m) && SCHARS (m) > 0)
 12093         {
 12094           set_message (m);
 12095           if (minibuffer_auto_raise)
 12096             Fraise_frame (frame);
 12097           /* Assume we are not echoing.
 12098              (If we are, echo_now will override this.)  */
 12099           echo_message_buffer = Qnil;
 12100         }
 12101       else
 12102         clear_message (true, true);
 12103 
 12104       do_pending_window_change (false);
 12105       echo_area_display (true);
 12106       do_pending_window_change (false);
 12107       if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
 12108         (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
 12109     }
 12110 }
 12111 
 12112 
 12113 /* Display a null-terminated echo area message M.  If M is 0, clear
 12114    out any existing message, and let the mini-buffer text show through.
 12115 
 12116    The buffer M must continue to exist until after the echo area gets
 12117    cleared or some other message gets displayed there.  Do not pass
 12118    text that is stored in a Lisp string.  Do not pass text in a buffer
 12119    that was alloca'd.  */
 12120 
 12121 void
 12122 message1 (const char *m)
 12123 {
 12124   message3 (m ? build_unibyte_string (m) : Qnil);
 12125 }
 12126 
 12127 
 12128 /* The non-logging counterpart of message1.  */
 12129 
 12130 void
 12131 message1_nolog (const char *m)
 12132 {
 12133   message3_nolog (m ? build_unibyte_string (m) : Qnil);
 12134 }
 12135 
 12136 /* Display a message M which contains a single %s
 12137    which gets replaced with STRING.  */
 12138 
 12139 void
 12140 message_with_string (const char *m, Lisp_Object string, bool log)
 12141 {
 12142   CHECK_STRING (string);
 12143 
 12144   bool need_message;
 12145   if (noninteractive)
 12146     need_message = !!m;
 12147   else if (!INTERACTIVE)
 12148     need_message = false;
 12149   else
 12150     {
 12151       /* The frame whose minibuffer we're going to display the message on.
 12152          It may be larger than the selected frame, so we need
 12153          to use its buffer, not the selected frame's buffer.  */
 12154       Lisp_Object mini_window;
 12155       struct frame *f, *sf = SELECTED_FRAME ();
 12156 
 12157       /* Get the frame containing the minibuffer
 12158          that the selected frame is using.  */
 12159       mini_window = FRAME_MINIBUF_WINDOW (sf);
 12160       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 12161 
 12162       /* Error messages get reported properly by cmd_error, so this must be
 12163          just an informative message; if the frame hasn't really been
 12164          initialized yet, just toss it.  */
 12165       need_message = f->glyphs_initialized_p;
 12166     }
 12167 
 12168   if (need_message)
 12169     {
 12170       AUTO_STRING (fmt, m);
 12171       Lisp_Object msg = CALLN (Fformat_message, fmt, string);
 12172 
 12173       if (noninteractive)
 12174         message_to_stderr (msg);
 12175       else
 12176         {
 12177           if (log)
 12178             message3 (msg);
 12179           else
 12180             message3_nolog (msg);
 12181 
 12182           /* Print should start at the beginning of the message
 12183              buffer next time.  */
 12184           message_buf_print = false;
 12185         }
 12186     }
 12187 }
 12188 
 12189 
 12190 /* Dump an informative message to the minibuf.  If M is 0, clear out
 12191    any existing message, and let the mini-buffer text show through.
 12192 
 12193    The message must be safe ASCII (because when Emacs is
 12194    non-interactive the message is sent straight to stderr without
 12195    encoding first) and the format must not contain ` or ' (because
 12196    this function does not account for `text-quoting-style').  If your
 12197    message and format do not fit into this category, convert your
 12198    arguments to Lisp objects and use Fmessage instead.  */
 12199 
 12200 static void ATTRIBUTE_FORMAT_PRINTF (1, 0)
 12201 vmessage (const char *m, va_list ap)
 12202 {
 12203   if (noninteractive)
 12204     {
 12205       if (m)
 12206         {
 12207           if (noninteractive_need_newline)
 12208             putc ('\n', stderr);
 12209           noninteractive_need_newline = false;
 12210           vfprintf (stderr, m, ap);
 12211           if (!cursor_in_echo_area)
 12212             putc ('\n', stderr);
 12213           fflush (stderr);
 12214         }
 12215     }
 12216   else if (INTERACTIVE)
 12217     {
 12218       /* The frame whose mini-buffer we're going to display the message
 12219          on.  It may be larger than the selected frame, so we need to
 12220          use its buffer, not the selected frame's buffer.  */
 12221       Lisp_Object mini_window;
 12222       struct frame *f, *sf = SELECTED_FRAME ();
 12223 
 12224       /* Get the frame containing the mini-buffer
 12225          that the selected frame is using.  */
 12226       mini_window = FRAME_MINIBUF_WINDOW (sf);
 12227       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 12228 
 12229       /* Error messages get reported properly by cmd_error, so this must be
 12230          just an informative message; if the frame hasn't really been
 12231          initialized yet, just toss it.  */
 12232       if (f->glyphs_initialized_p)
 12233         {
 12234           if (m)
 12235             {
 12236               ptrdiff_t len;
 12237               ptrdiff_t maxsize = FRAME_MESSAGE_BUF_SIZE (f);
 12238               USE_SAFE_ALLOCA;
 12239               char *message_buf = SAFE_ALLOCA (maxsize + 1);
 12240 
 12241               len = doprnt (message_buf, maxsize, m, 0, ap);
 12242 
 12243               message3 (make_string (message_buf, len));
 12244               SAFE_FREE ();
 12245             }
 12246           else
 12247             message1 (0);
 12248 
 12249           /* Print should start at the beginning of the message
 12250              buffer next time.  */
 12251           message_buf_print = false;
 12252         }
 12253     }
 12254 }
 12255 
 12256 /* See vmessage for restrictions on the text of the message.  */
 12257 void
 12258 message (const char *m, ...)
 12259 {
 12260   va_list ap;
 12261   va_start (ap, m);
 12262   vmessage (m, ap);
 12263   va_end (ap);
 12264 }
 12265 
 12266 
 12267 /* Display the current message in the current mini-buffer.  This is
 12268    only called from error handlers in process.c, and is not time
 12269    critical.  */
 12270 
 12271 void
 12272 update_echo_area (void)
 12273 {
 12274   if (!NILP (echo_area_buffer[0]))
 12275     {
 12276       Lisp_Object string;
 12277       string = Fcurrent_message ();
 12278       message3 (string);
 12279     }
 12280 }
 12281 
 12282 
 12283 /* Make sure echo area buffers in `echo_buffers' are live.
 12284    If they aren't, make new ones.  */
 12285 
 12286 static void
 12287 ensure_echo_area_buffers (void)
 12288 {
 12289   for (int i = 0; i < 2; i++)
 12290     if (!BUFFERP (echo_buffer[i])
 12291         || !BUFFER_LIVE_P (XBUFFER (echo_buffer[i])))
 12292       {
 12293         Lisp_Object old_buffer = echo_buffer[i];
 12294         static char const name_fmt[] = " *Echo Area %d*";
 12295         char name[sizeof name_fmt + INT_STRLEN_BOUND (int)];
 12296         AUTO_STRING_WITH_LEN (lname, name, sprintf (name, name_fmt, i));
 12297         echo_buffer[i] = Fget_buffer_create (lname, Qnil);
 12298         bset_truncate_lines (XBUFFER (echo_buffer[i]), Qnil);
 12299         /* to force word wrap in echo area -
 12300            it was decided to postpone this*/
 12301         /* XBUFFER (echo_buffer[i])->word_wrap = Qt; */
 12302 
 12303         for (int j = 0; j < 2; j++)
 12304           if (EQ (old_buffer, echo_area_buffer[j]))
 12305             echo_area_buffer[j] = echo_buffer[i];
 12306       }
 12307 }
 12308 
 12309 
 12310 /* Call FN with args A1..A2 with either the current or last displayed
 12311    echo_area_buffer as current buffer.
 12312 
 12313    WHICH zero means use the current message buffer
 12314    echo_area_buffer[0].  If that is nil, choose a suitable buffer
 12315    from echo_buffer[] and clear it.
 12316 
 12317    WHICH > 0 means use echo_area_buffer[1].  If that is nil, choose a
 12318    suitable buffer from echo_buffer[] and clear it.
 12319 
 12320    If WHICH < 0, set echo_area_buffer[1] to echo_area_buffer[0], so
 12321    that the current message becomes the last displayed one, choose a
 12322    suitable buffer for echo_area_buffer[0], and clear it.
 12323 
 12324    Value is what FN returns.  */
 12325 
 12326 static bool
 12327 with_echo_area_buffer (struct window *w, int which,
 12328                        bool (*fn) (void *, Lisp_Object),
 12329                        void *a1, Lisp_Object a2)
 12330 {
 12331   Lisp_Object buffer;
 12332   bool this_one, the_other, clear_buffer_p, rc;
 12333   specpdl_ref count = SPECPDL_INDEX ();
 12334 
 12335   /* If buffers aren't live, make new ones.  */
 12336   ensure_echo_area_buffers ();
 12337 
 12338   clear_buffer_p = false;
 12339 
 12340   if (which == 0)
 12341     this_one = false, the_other = true;
 12342   else if (which > 0)
 12343     this_one = true, the_other = false;
 12344   else
 12345     {
 12346       this_one = false, the_other = true;
 12347       clear_buffer_p = true;
 12348 
 12349       /* We need a fresh one in case the current echo buffer equals
 12350          the one containing the last displayed echo area message.  */
 12351       if (!NILP (echo_area_buffer[this_one])
 12352           && EQ (echo_area_buffer[this_one], echo_area_buffer[the_other]))
 12353         echo_area_buffer[this_one] = Qnil;
 12354     }
 12355 
 12356   /* Choose a suitable buffer from echo_buffer[] if we don't
 12357      have one.  */
 12358   if (NILP (echo_area_buffer[this_one]))
 12359     {
 12360       echo_area_buffer[this_one]
 12361         = (EQ (echo_area_buffer[the_other], echo_buffer[this_one])
 12362            ? echo_buffer[the_other]
 12363            : echo_buffer[this_one]);
 12364       clear_buffer_p = true;
 12365     }
 12366 
 12367   buffer = echo_area_buffer[this_one];
 12368 
 12369   /* Don't get confused by reusing the buffer used for echoing
 12370      for a different purpose.  */
 12371   if (echo_kboard == NULL && EQ (buffer, echo_message_buffer))
 12372     cancel_echoing ();
 12373 
 12374   record_unwind_protect (unwind_with_echo_area_buffer,
 12375                          with_echo_area_buffer_unwind_data (w));
 12376 
 12377   /* Make the echo area buffer current.  Note that for display
 12378      purposes, it is not necessary that the displayed window's buffer
 12379      == current_buffer, except for text property lookup.  So, let's
 12380      only set that buffer temporarily here without doing a full
 12381      Fset_window_buffer.  We must also change w->pointm, though,
 12382      because otherwise an assertions in unshow_buffer fails, and Emacs
 12383      aborts.  */
 12384   set_buffer_internal_1 (XBUFFER (buffer));
 12385   if (w)
 12386     {
 12387       wset_buffer (w, buffer);
 12388       set_marker_both (w->pointm, buffer, BEG, BEG_BYTE);
 12389       set_marker_both (w->old_pointm, buffer, BEG, BEG_BYTE);
 12390     }
 12391 
 12392   bset_undo_list (current_buffer, Qt);
 12393   bset_read_only (current_buffer, Qnil);
 12394   specbind (Qinhibit_read_only, Qt);
 12395   specbind (Qinhibit_modification_hooks, Qt);
 12396 
 12397   if (clear_buffer_p && Z > BEG)
 12398     del_range (BEG, Z);
 12399 
 12400   eassert (BEGV >= BEG);
 12401   eassert (ZV <= Z && ZV >= BEGV);
 12402 
 12403   rc = fn (a1, a2);
 12404 
 12405   eassert (BEGV >= BEG);
 12406   eassert (ZV <= Z && ZV >= BEGV);
 12407 
 12408   unbind_to (count, Qnil);
 12409   return rc;
 12410 }
 12411 
 12412 
 12413 /* Save state that should be preserved around the call to the function
 12414    FN called in with_echo_area_buffer.  */
 12415 
 12416 static Lisp_Object
 12417 with_echo_area_buffer_unwind_data (struct window *w)
 12418 {
 12419   int i = 0;
 12420   Lisp_Object vector, tmp;
 12421 
 12422   /* Reduce consing by keeping one vector in
 12423      Vwith_echo_area_save_vector.  */
 12424   vector = Vwith_echo_area_save_vector;
 12425   Vwith_echo_area_save_vector = Qnil;
 12426 
 12427   if (NILP (vector))
 12428     vector = make_nil_vector (11);
 12429 
 12430   XSETBUFFER (tmp, current_buffer); ASET (vector, i, tmp); ++i;
 12431   ASET (vector, i, Vdeactivate_mark); ++i;
 12432   ASET (vector, i, make_fixnum (windows_or_buffers_changed)); ++i;
 12433 
 12434   if (w)
 12435     {
 12436       XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
 12437       ASET (vector, i, w->contents); ++i;
 12438       ASET (vector, i, make_fixnum (marker_position (w->pointm))); ++i;
 12439       ASET (vector, i, make_fixnum (marker_byte_position (w->pointm))); ++i;
 12440       ASET (vector, i, make_fixnum (marker_position (w->old_pointm))); ++i;
 12441       ASET (vector, i, make_fixnum (marker_byte_position (w->old_pointm))); ++i;
 12442       ASET (vector, i, make_fixnum (marker_position (w->start))); ++i;
 12443       ASET (vector, i, make_fixnum (marker_byte_position (w->start))); ++i;
 12444     }
 12445   else
 12446     {
 12447       int end = i + 8;
 12448       for (; i < end; ++i)
 12449         ASET (vector, i, Qnil);
 12450     }
 12451 
 12452   eassert (i == ASIZE (vector));
 12453   return vector;
 12454 }
 12455 
 12456 
 12457 /* Restore global state from VECTOR which was created by
 12458    with_echo_area_buffer_unwind_data.  */
 12459 
 12460 static void
 12461 unwind_with_echo_area_buffer (Lisp_Object vector)
 12462 {
 12463   set_buffer_internal_1 (XBUFFER (AREF (vector, 0)));
 12464   Vdeactivate_mark = AREF (vector, 1);
 12465   windows_or_buffers_changed = XFIXNAT (AREF (vector, 2));
 12466 
 12467   if (WINDOWP (AREF (vector, 3)))
 12468     {
 12469       struct window *w;
 12470       Lisp_Object buffer;
 12471 
 12472       w = XWINDOW (AREF (vector, 3));
 12473       buffer = AREF (vector, 4);
 12474 
 12475       wset_buffer (w, buffer);
 12476       set_marker_restricted_both (w->pointm, buffer,
 12477                                   XFIXNAT (AREF (vector, 5)),
 12478                                   XFIXNAT (AREF (vector, 6)));
 12479       set_marker_restricted_both (w->old_pointm, buffer,
 12480                                   XFIXNAT (AREF (vector, 7)),
 12481                                   XFIXNAT (AREF (vector, 8)));
 12482       set_marker_restricted_both (w->start, buffer,
 12483                                   XFIXNAT (AREF (vector, 9)),
 12484                                   XFIXNAT (AREF (vector, 10)));
 12485     }
 12486 
 12487   Vwith_echo_area_save_vector = vector;
 12488 }
 12489 
 12490 
 12491 /* Set up the echo area for use by print functions.  MULTIBYTE_P
 12492    means we will print multibyte.  */
 12493 
 12494 void
 12495 setup_echo_area_for_printing (bool multibyte_p)
 12496 {
 12497   /* If we can't find an echo area any more, exit.  */
 12498   if (! FRAME_LIVE_P (XFRAME (selected_frame)))
 12499     Fkill_emacs (Qnil, Qnil);
 12500 
 12501   ensure_echo_area_buffers ();
 12502 
 12503   if (!message_buf_print)
 12504     {
 12505       /* A message has been output since the last time we printed.
 12506          Choose a fresh echo area buffer.  */
 12507       if (EQ (echo_area_buffer[1], echo_buffer[0]))
 12508         echo_area_buffer[0] = echo_buffer[1];
 12509       else
 12510         echo_area_buffer[0] = echo_buffer[0];
 12511 
 12512       /* Switch to that buffer and clear it.  */
 12513       set_buffer_internal (XBUFFER (echo_area_buffer[0]));
 12514       bset_truncate_lines (current_buffer, Qnil);
 12515 
 12516       if (Z > BEG)
 12517         {
 12518           specpdl_ref count = SPECPDL_INDEX ();
 12519           specbind (Qinhibit_read_only, Qt);
 12520           /* Note that undo recording is always disabled.  */
 12521           del_range (BEG, Z);
 12522           unbind_to (count, Qnil);
 12523         }
 12524       TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
 12525 
 12526       /* Set up the buffer for the multibyteness we need.  We always
 12527          set it to be multibyte, except when
 12528          unibyte-display-via-language-environment is non-nil and the
 12529          buffer from which we are called is unibyte, because in that
 12530          case unibyte characters should not be displayed as octal
 12531          escapes.  */
 12532       if (unibyte_display_via_language_environment
 12533           && !multibyte_p
 12534           && !NILP (BVAR (current_buffer, enable_multibyte_characters)))
 12535         Fset_buffer_multibyte (Qnil);
 12536       else if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
 12537         Fset_buffer_multibyte (Qt);
 12538 
 12539       /* Raise the frame containing the echo area.  */
 12540       if (minibuffer_auto_raise)
 12541         {
 12542           struct frame *sf = SELECTED_FRAME ();
 12543           Lisp_Object mini_window;
 12544           mini_window = FRAME_MINIBUF_WINDOW (sf);
 12545           Fraise_frame  (WINDOW_FRAME (XWINDOW (mini_window)));
 12546         }
 12547 
 12548       message_log_maybe_newline ();
 12549       message_buf_print = true;
 12550     }
 12551   else
 12552     {
 12553       if (NILP (echo_area_buffer[0]))
 12554         {
 12555           if (EQ (echo_area_buffer[1], echo_buffer[0]))
 12556             echo_area_buffer[0] = echo_buffer[1];
 12557           else
 12558             echo_area_buffer[0] = echo_buffer[0];
 12559         }
 12560 
 12561       if (current_buffer != XBUFFER (echo_area_buffer[0]))
 12562         {
 12563           /* Someone switched buffers between print requests.  */
 12564           set_buffer_internal (XBUFFER (echo_area_buffer[0]));
 12565           bset_truncate_lines (current_buffer, Qnil);
 12566         }
 12567     }
 12568 }
 12569 
 12570 
 12571 /* Display an echo area message in window W.  Value is true if W's
 12572    height is changed.  If display_last_displayed_message_p,
 12573    display the message that was last displayed, otherwise
 12574    display the current message.  */
 12575 
 12576 static bool
 12577 display_echo_area (struct window *w)
 12578 {
 12579   bool no_message_p, window_height_changed_p;
 12580 
 12581   /* Temporarily disable garbage collections while displaying the echo
 12582      area.  This is done because a GC can print a message itself.
 12583      That message would modify the echo area buffer's contents while a
 12584      redisplay of the buffer is going on, and seriously confuse
 12585      redisplay.  */
 12586   specpdl_ref count = inhibit_garbage_collection ();
 12587 
 12588   /* If there is no message, we must call display_echo_area_1
 12589      nevertheless because it resizes the window.  But we will have to
 12590      reset the echo_area_buffer in question to nil at the end because
 12591      with_echo_area_buffer will set it to an empty buffer.  */
 12592   bool i = display_last_displayed_message_p;
 12593   /* According to the C standard, the integral value
 12594      of a "bool" is always 0 or 1, so this array access is safe here,
 12595      if oddly typed. */
 12596   no_message_p = NILP (echo_area_buffer[i]);
 12597 
 12598   window_height_changed_p
 12599     = with_echo_area_buffer (w, display_last_displayed_message_p,
 12600                              display_echo_area_1, w, Qnil);
 12601 
 12602   if (no_message_p)
 12603     echo_area_buffer[i] = Qnil;
 12604 
 12605   unbind_to (count, Qnil);
 12606   return window_height_changed_p;
 12607 }
 12608 
 12609 
 12610 /* Helper for display_echo_area.  Display the current buffer which
 12611    contains the current echo area message in window W, a mini-window,
 12612    a pointer to which is passed in A1.  A2 is currently not used.
 12613    Change the height of W so that all of the message is displayed.
 12614    Value is true if height of W was changed.  */
 12615 
 12616 static bool
 12617 display_echo_area_1 (void *a1, Lisp_Object a2)
 12618 {
 12619   struct window *w = a1;
 12620   Lisp_Object window;
 12621   struct text_pos start;
 12622 
 12623   /* We are about to enter redisplay without going through
 12624      redisplay_internal, so we need to forget these faces by hand
 12625      here.  */
 12626   forget_escape_and_glyphless_faces ();
 12627 
 12628   /* Do this before displaying, so that we have a large enough glyph
 12629      matrix for the display.  If we can't get enough space for the
 12630      whole text, display the last N lines.  That works by setting w->start.  */
 12631   bool window_height_changed_p = resize_mini_window (w, false);
 12632 
 12633   /* Use the starting position chosen by resize_mini_window.  */
 12634   SET_TEXT_POS_FROM_MARKER (start, w->start);
 12635 
 12636   /* Display.  */
 12637   clear_glyph_matrix (w->desired_matrix);
 12638   XSETWINDOW (window, w);
 12639   void *itdata = bidi_shelve_cache ();
 12640   try_window (window, start, 0);
 12641   bidi_unshelve_cache (itdata, false);
 12642 
 12643   return window_height_changed_p;
 12644 }
 12645 
 12646 
 12647 /* Resize the echo area window to exactly the size needed for the
 12648    currently displayed message, if there is one.  If a mini-buffer
 12649    is active, don't shrink it.  */
 12650 
 12651 void
 12652 resize_echo_area_exactly (void)
 12653 {
 12654   if (BUFFERP (echo_area_buffer[0])
 12655       && WINDOWP (echo_area_window))
 12656     {
 12657       struct window *w = XWINDOW (echo_area_window);
 12658       Lisp_Object resize_exactly = (minibuf_level == 0 ? Qt : Qnil);
 12659       bool resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
 12660                                               w, resize_exactly);
 12661       if (resized_p)
 12662         {
 12663           windows_or_buffers_changed = 42;
 12664           update_mode_lines = 30;
 12665           redisplay_internal ();
 12666         }
 12667     }
 12668 }
 12669 
 12670 
 12671 /* Callback function for with_echo_area_buffer, when used from
 12672    resize_echo_area_exactly.  A1 contains a pointer to the window to
 12673    resize, EXACTLY non-nil means resize the mini-window exactly to the
 12674    size of the text displayed.  Value is what resize_mini_window
 12675    returns.  */
 12676 
 12677 static bool
 12678 resize_mini_window_1 (void *a1, Lisp_Object exactly)
 12679 {
 12680   return resize_mini_window (a1, !NILP (exactly));
 12681 }
 12682 
 12683 
 12684 /* Resize mini-window W to fit the size of its contents.  EXACT_P
 12685    means size the window exactly to the size needed.  Otherwise, it's
 12686    only enlarged until W's buffer is empty.
 12687 
 12688    Set W->start to the right place to begin display.  If the whole
 12689    contents fit, start at the beginning.  Otherwise, start so as
 12690    to make the end of the contents appear.  This is particularly
 12691    important for y-or-n-p, but seems desirable generally.
 12692 
 12693    Value is true if the window height has been changed.  */
 12694 
 12695 bool
 12696 resize_mini_window (struct window *w, bool exact_p)
 12697 {
 12698   struct frame *f = XFRAME (w->frame);
 12699   int old_height = WINDOW_BOX_TEXT_HEIGHT (w);
 12700 
 12701   eassert (MINI_WINDOW_P (w));
 12702 
 12703   /* Don't resize windows while redisplaying a window; it would
 12704      confuse redisplay functions when the size of the window they are
 12705      displaying changes from under them.  Such a resizing can happen,
 12706      for instance, when which-func prints a long message while
 12707      we are running fontification-functions.  We're running these
 12708      functions with safe_call which binds inhibit-redisplay to t.  */
 12709   if (!NILP (Vinhibit_redisplay))
 12710     return false;
 12711 
 12712   /* By default, start display at the beginning.  */
 12713   if (redisplay_adhoc_scroll_in_resize_mini_windows)
 12714     set_marker_both (w->start, w->contents,
 12715                      BUF_BEGV (XBUFFER (w->contents)),
 12716                      BUF_BEGV_BYTE (XBUFFER (w->contents)));
 12717 
 12718   /* Nil means don't try to resize.  */
 12719   if ((NILP (Vresize_mini_windows)
 12720        && (NILP (resize_mini_frames) || !FRAME_MINIBUF_ONLY_P (f)))
 12721       || (FRAME_X_P (f) && FRAME_OUTPUT_DATA (f) == NULL))
 12722     return false;
 12723 
 12724   if (FRAME_MINIBUF_ONLY_P (f))
 12725     {
 12726       if (!NILP (resize_mini_frames))
 12727         safe_call1 (Qwindow__resize_mini_frame, WINDOW_FRAME (w));
 12728     }
 12729   else
 12730     {
 12731       struct it it;
 12732       int unit = FRAME_LINE_HEIGHT (f);
 12733       int height, max_height;
 12734       struct text_pos start;
 12735       struct buffer *old_current_buffer = NULL;
 12736       int windows_height = FRAME_INNER_HEIGHT (f);
 12737 
 12738       if (current_buffer != XBUFFER (w->contents))
 12739         {
 12740           old_current_buffer = current_buffer;
 12741           set_buffer_internal (XBUFFER (w->contents));
 12742         }
 12743 
 12744       init_iterator (&it, w, BEGV, BEGV_BYTE, NULL, DEFAULT_FACE_ID);
 12745 
 12746       /* Compute the max. number of lines specified by the user.  */
 12747       if (FLOATP (Vmax_mini_window_height))
 12748         max_height = XFLOAT_DATA (Vmax_mini_window_height) * windows_height;
 12749       else if (FIXNUMP (Vmax_mini_window_height))
 12750         max_height = XFIXNUM (Vmax_mini_window_height) * unit;
 12751       else
 12752         max_height = windows_height / 4;
 12753 
 12754       /* Correct that max. height if it's bogus.  */
 12755       max_height = clip_to_bounds (unit, max_height, windows_height);
 12756 
 12757       /* Find out the height of the text in the window.  */
 12758       last_height = 0;
 12759       move_it_to (&it, ZV, -1, -1, -1, MOVE_TO_POS);
 12760       /* If move_it_to moved to the next visible line after EOB,
 12761          account for the height of the last full line.  */
 12762       if (it.max_ascent == 0 && it.max_descent == 0)
 12763         {
 12764           height = it.current_y;
 12765           /* Don't add the last line's height if lines are truncated
 12766              and the text doesn't end in a newline.
 12767              FIXME: if the text ends in a newline from a display
 12768              property or an overlay string, they lose: the mini-window
 12769              might not show the last empty line.  */
 12770           if (!(it.line_wrap == TRUNCATE
 12771                 && it.current_x <= it.first_visible_x
 12772                 && ZV_BYTE > 1
 12773                 && FETCH_BYTE (ZV_BYTE - 1) != '\n'))
 12774             height += last_height;
 12775         }
 12776       else
 12777         height = it.current_y + it.max_ascent + it.max_descent;
 12778       height -= min (it.extra_line_spacing, it.max_extra_line_spacing);
 12779 
 12780       /* Compute a suitable window start.  */
 12781       if (height > max_height)
 12782         {
 12783           height = (max_height / unit) * unit;
 12784           if (redisplay_adhoc_scroll_in_resize_mini_windows)
 12785             {
 12786               init_iterator (&it, w, ZV, ZV_BYTE, NULL, DEFAULT_FACE_ID);
 12787               move_it_vertically_backward (&it, height - unit);
 12788               /* The following move is usually a no-op when the stuff
 12789                  displayed in the mini-window comes entirely from buffer
 12790                  text, but it is needed when some of it comes from overlay
 12791                  strings, especially when there's an after-string at ZV.
 12792                  This happens with some completion packages, like
 12793                  icomplete, ido-vertical, etc.  With those packages, if we
 12794                  don't force w->start to be at the beginning of a screen
 12795                  line, important parts of the stuff in the mini-window,
 12796                  such as user prompt, will be hidden from view.  */
 12797               move_it_by_lines (&it, 0);
 12798               start = it.current.pos;
 12799               /* Prevent redisplay_window from recentering, and thus from
 12800                  overriding the window-start point we computed here.  */
 12801               w->start_at_line_beg = false;
 12802               SET_MARKER_FROM_TEXT_POS (w->start, start);
 12803             }
 12804         }
 12805       else
 12806         {
 12807           SET_TEXT_POS (start, BEGV, BEGV_BYTE);
 12808           SET_MARKER_FROM_TEXT_POS (w->start, start);
 12809         }
 12810 
 12811       if (EQ (Vresize_mini_windows, Qgrow_only))
 12812         {
 12813           /* Let it grow only, until we display an empty message, in which
 12814              case the window shrinks again.  */
 12815           if (height > old_height)
 12816             grow_mini_window (w, height - old_height);
 12817           else if (height < old_height && (exact_p || BEGV == ZV))
 12818             shrink_mini_window (w);
 12819         }
 12820       else if (height != old_height)
 12821         /* Always resize to exact size needed.  */
 12822         grow_mini_window (w, height - old_height);
 12823 
 12824       if (old_current_buffer)
 12825         set_buffer_internal (old_current_buffer);
 12826     }
 12827 
 12828   return WINDOW_BOX_TEXT_HEIGHT (w) != old_height;
 12829 }
 12830 
 12831 
 12832 /* Value is the current message, a string, or nil if there is no
 12833    current message.  */
 12834 
 12835 Lisp_Object
 12836 current_message (void)
 12837 {
 12838   Lisp_Object msg;
 12839 
 12840   if (!BUFFERP (echo_area_buffer[0]))
 12841     msg = Qnil;
 12842   else
 12843     {
 12844       with_echo_area_buffer (0, 0, current_message_1, &msg, Qnil);
 12845       if (NILP (msg))
 12846         echo_area_buffer[0] = Qnil;
 12847     }
 12848 
 12849   return msg;
 12850 }
 12851 
 12852 
 12853 static bool
 12854 current_message_1 (void *a1, Lisp_Object a2)
 12855 {
 12856   Lisp_Object *msg = a1;
 12857 
 12858   if (Z > BEG)
 12859     *msg = make_buffer_string (BEG, Z, true);
 12860   else
 12861     *msg = Qnil;
 12862   return false;
 12863 }
 12864 
 12865 
 12866 /* Push the current message on Vmessage_stack for later restoration
 12867    by restore_message.  Value is true if the current message isn't
 12868    empty.  This is a relatively infrequent operation, so it's not
 12869    worth optimizing.  */
 12870 
 12871 bool
 12872 push_message (void)
 12873 {
 12874   Lisp_Object msg = current_message ();
 12875   Vmessage_stack = Fcons (msg, Vmessage_stack);
 12876   return STRINGP (msg);
 12877 }
 12878 
 12879 
 12880 /* Restore message display from the top of Vmessage_stack.  */
 12881 
 12882 void
 12883 restore_message (void)
 12884 {
 12885   eassert (CONSP (Vmessage_stack));
 12886   message3_nolog (XCAR (Vmessage_stack));
 12887 }
 12888 
 12889 
 12890 /* Handler for unwind-protect calling pop_message.  */
 12891 
 12892 void
 12893 pop_message_unwind (void)
 12894 {
 12895   /* Pop the top-most entry off Vmessage_stack.  */
 12896   eassert (CONSP (Vmessage_stack));
 12897   Vmessage_stack = XCDR (Vmessage_stack);
 12898 }
 12899 
 12900 
 12901 /* Check that Vmessage_stack is nil.  Called from emacs.c when Emacs
 12902    exits.  If the stack is not empty, we have a missing
 12903    pop_message_unwind somewhere.  */
 12904 
 12905 void
 12906 check_message_stack (void)
 12907 {
 12908   if (!NILP (Vmessage_stack))
 12909     emacs_abort ();
 12910 }
 12911 
 12912 void
 12913 clear_message_stack (void)
 12914 {
 12915   Vmessage_stack = Qnil;
 12916 }
 12917 
 12918 /* Truncate to NCHARS what will be displayed in the echo area the next
 12919    time we display it---but don't redisplay it now.  */
 12920 
 12921 void
 12922 truncate_echo_area (ptrdiff_t nchars)
 12923 {
 12924   if (nchars == 0)
 12925     echo_area_buffer[0] = Qnil;
 12926   else if (!noninteractive
 12927            && INTERACTIVE
 12928            && !NILP (echo_area_buffer[0]))
 12929     {
 12930       struct frame *sf = SELECTED_FRAME ();
 12931       /* Error messages get reported properly by cmd_error, so this must be
 12932          just an informative message; if the frame hasn't really been
 12933          initialized yet, just toss it.  */
 12934       if (sf->glyphs_initialized_p)
 12935         with_echo_area_buffer (0, 0, truncate_message_1,
 12936                                (void *) (intptr_t) nchars, Qnil);
 12937     }
 12938 }
 12939 
 12940 
 12941 /* Helper function for truncate_echo_area.  Truncate the current
 12942    message to at most NCHARS characters.  */
 12943 
 12944 static bool
 12945 truncate_message_1 (void *a1, Lisp_Object a2)
 12946 {
 12947   intptr_t nchars = (intptr_t) a1;
 12948   if (BEG + nchars < Z)
 12949     del_range (BEG + nchars, Z);
 12950   if (Z == BEG)
 12951     echo_area_buffer[0] = Qnil;
 12952   return false;
 12953 }
 12954 
 12955 extern intptr_t garbage_collection_inhibited;
 12956 
 12957 /* Set the current message to STRING.  */
 12958 
 12959 static void
 12960 set_message (Lisp_Object string)
 12961 {
 12962   Lisp_Object message = Qnil;
 12963 
 12964   eassert (STRINGP (string));
 12965 
 12966   if (FUNCTIONP (Vset_message_function)
 12967       /* FIXME: (bug#63253) We should really make the regexp engine re-entrant,
 12968          but in the mean time, let's ignore `set-message-function` when
 12969          called from `probably_quit`.  */
 12970       && !garbage_collection_inhibited)
 12971     {
 12972       specpdl_ref count = SPECPDL_INDEX ();
 12973       specbind (Qinhibit_quit, Qt);
 12974       message = safe_call1 (Vset_message_function, string);
 12975       unbind_to (count, Qnil);
 12976 
 12977       if (STRINGP (message))
 12978         {
 12979           string = message;
 12980           message = Qnil;
 12981         }
 12982     }
 12983 
 12984   if (NILP (message))
 12985     {
 12986       message_enable_multibyte = STRING_MULTIBYTE (string);
 12987 
 12988       with_echo_area_buffer (0, -1, set_message_1, 0, string);
 12989       message_buf_print = false;
 12990       help_echo_showing_p = false;
 12991     }
 12992 
 12993   if (STRINGP (Vdebug_on_message)
 12994       && STRINGP (string)
 12995       && fast_string_match (Vdebug_on_message, string) >= 0)
 12996     call_debugger (list2 (Qerror, string));
 12997 }
 12998 
 12999 
 13000 /* Helper function for set_message.  First argument is ignored and second
 13001    argument has the same meaning as for set_message.
 13002    This function is called with the echo area buffer being current.  */
 13003 
 13004 static bool
 13005 set_message_1 (void *a1, Lisp_Object string)
 13006 {
 13007   eassert (STRINGP (string));
 13008 
 13009   /* Change multibyteness of the echo buffer appropriately.  We always
 13010      set it to be multibyte, except when
 13011      unibyte-display-via-language-environment is non-nil and the
 13012      string to display is unibyte, because in that case unibyte
 13013      characters should not be displayed as octal escapes.  */
 13014   if (!message_enable_multibyte
 13015       && unibyte_display_via_language_environment
 13016       && !NILP (BVAR (current_buffer, enable_multibyte_characters)))
 13017     Fset_buffer_multibyte (Qnil);
 13018   else if (NILP (BVAR (current_buffer, enable_multibyte_characters)))
 13019     Fset_buffer_multibyte (Qt);
 13020 
 13021   bset_truncate_lines (current_buffer, message_truncate_lines ? Qt : Qnil);
 13022   if (!NILP (BVAR (current_buffer, bidi_display_reordering)))
 13023     bset_bidi_paragraph_direction (current_buffer, Qleft_to_right);
 13024 
 13025   /* Insert new message at BEG.  */
 13026   TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
 13027 
 13028   /* This function takes care of single/multibyte conversion.
 13029      We just have to ensure that the echo area buffer has the right
 13030      setting of enable_multibyte_characters.  */
 13031   insert_from_string (string, 0, 0, SCHARS (string), SBYTES (string), true);
 13032 
 13033   return false;
 13034 }
 13035 
 13036 
 13037 /* Clear messages.  CURRENT_P means clear the current message.
 13038    LAST_DISPLAYED_P means clear the message last displayed.  */
 13039 
 13040 void
 13041 clear_message (bool current_p, bool last_displayed_p)
 13042 {
 13043   Lisp_Object preserve = Qnil;
 13044 
 13045   if (current_p)
 13046     {
 13047       if (FUNCTIONP (Vclear_message_function)
 13048           /* FIXME: (bug#63253) Same as for `set-message-function` above.  */
 13049           && !garbage_collection_inhibited)
 13050         {
 13051           specpdl_ref count = SPECPDL_INDEX ();
 13052           specbind (Qinhibit_quit, Qt);
 13053           preserve = safe_call (1, Vclear_message_function);
 13054           unbind_to (count, Qnil);
 13055         }
 13056 
 13057       if (!EQ (preserve, Qdont_clear_message))
 13058         {
 13059           echo_area_buffer[0] = Qnil;
 13060           message_cleared_p = true;
 13061         }
 13062     }
 13063 
 13064   if (last_displayed_p)
 13065     echo_area_buffer[1] = Qnil;
 13066 
 13067   message_buf_print = false;
 13068 }
 13069 
 13070 /* Clear garbaged frames.
 13071 
 13072    This function is used where the old redisplay called
 13073    redraw_garbaged_frames which in turn called redraw_frame which in
 13074    turn called clear_frame.  The call to clear_frame was a source of
 13075    flickering.  I believe a clear_frame is not necessary.  It should
 13076    suffice in the new redisplay to invalidate all current matrices,
 13077    and ensure a complete redisplay of all windows.  */
 13078 
 13079 static void
 13080 clear_garbaged_frames (void)
 13081 {
 13082   if (frame_garbaged)
 13083     {
 13084       Lisp_Object tail, frame;
 13085       struct frame *sf = SELECTED_FRAME ();
 13086 
 13087       FOR_EACH_FRAME (tail, frame)
 13088         {
 13089           struct frame *f = XFRAME (frame);
 13090 
 13091           if (FRAME_REDISPLAY_P (f) && FRAME_GARBAGED_P (f))
 13092             {
 13093               if (f->resized_p
 13094                   /* It makes no sense to redraw a non-selected TTY
 13095                      frame, since that will actually clear the
 13096                      selected frame, and might leave the selected
 13097                      frame with corrupted display, if it happens not
 13098                      to be marked garbaged.  */
 13099                   && !(f != sf && (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))))
 13100                 redraw_frame (f);
 13101               else
 13102                 clear_current_matrices (f);
 13103 
 13104 #ifdef HAVE_WINDOW_SYSTEM
 13105               if (FRAME_WINDOW_P (f)
 13106                   && FRAME_RIF (f)->clear_under_internal_border)
 13107                 FRAME_RIF (f)->clear_under_internal_border (f);
 13108 #endif
 13109               fset_redisplay (f);
 13110               f->garbaged = false;
 13111               f->resized_p = false;
 13112             }
 13113         }
 13114 
 13115       frame_garbaged = false;
 13116     }
 13117 }
 13118 
 13119 
 13120 /* Redisplay the echo area of the selected frame.  If UPDATE_FRAME_P, update
 13121    selected_frame.  */
 13122 
 13123 static void
 13124 echo_area_display (bool update_frame_p)
 13125 {
 13126   Lisp_Object mini_window;
 13127   struct window *w;
 13128   struct frame *f;
 13129   bool window_height_changed_p = false;
 13130   struct frame *sf = SELECTED_FRAME ();
 13131 
 13132   mini_window = FRAME_MINIBUF_WINDOW (sf);
 13133   if (NILP (mini_window))
 13134     return;
 13135 
 13136   w = XWINDOW (mini_window);
 13137   f = XFRAME (WINDOW_FRAME (w));
 13138 
 13139   /* Don't display if frame is invisible or not yet initialized.  */
 13140   if (!FRAME_REDISPLAY_P (f) || !f->glyphs_initialized_p)
 13141     return;
 13142 
 13143 #ifdef HAVE_WINDOW_SYSTEM
 13144   /* When Emacs starts, selected_frame may be the initial terminal
 13145      frame.  If we let this through, a message would be displayed on
 13146      the terminal.  */
 13147   if (FRAME_INITIAL_P (XFRAME (selected_frame)))
 13148     return;
 13149 #endif /* HAVE_WINDOW_SYSTEM */
 13150 
 13151   /* Redraw garbaged frames.  */
 13152   clear_garbaged_frames ();
 13153 
 13154   if (!NILP (echo_area_buffer[0]) || minibuf_level == 0)
 13155     {
 13156       echo_area_window = mini_window;
 13157       window_height_changed_p = display_echo_area (w);
 13158       w->must_be_updated_p = true;
 13159 
 13160       /* Update the display, unless called from redisplay_internal.
 13161          Also don't update the screen during redisplay itself.  The
 13162          update will happen at the end of redisplay, and an update
 13163          here could cause confusion.  */
 13164       if (update_frame_p && !redisplaying_p)
 13165         {
 13166           int n = 0;
 13167 
 13168           /* If the display update has been interrupted by pending
 13169              input, update mode lines in the frame.  Due to the
 13170              pending input, it might have been that redisplay hasn't
 13171              been called, so that mode lines above the echo area are
 13172              garbaged.  This looks odd, so we prevent it here.  */
 13173           if (!display_completed)
 13174             {
 13175               n = redisplay_mode_lines (FRAME_ROOT_WINDOW (f), false);
 13176 
 13177 #ifdef HAVE_WINDOW_SYSTEM
 13178               if (FRAME_WINDOW_P (f)
 13179                   && FRAME_RIF (f)->clear_under_internal_border)
 13180                 FRAME_RIF (f)->clear_under_internal_border (f);
 13181 #endif
 13182             }
 13183 
 13184           if (window_height_changed_p
 13185               /* Don't do this if Emacs is shutting down.  Redisplay
 13186                  needs to run hooks.  */
 13187               && !NILP (Vrun_hooks))
 13188             {
 13189               /* Must update other windows.  Likewise as in other
 13190                  cases, don't let this update be interrupted by
 13191                  pending input.  */
 13192               specpdl_ref count = SPECPDL_INDEX ();
 13193               specbind (Qredisplay_dont_pause, Qt);
 13194               fset_redisplay (f);
 13195               redisplay_internal ();
 13196               unbind_to (count, Qnil);
 13197             }
 13198           else if (FRAME_WINDOW_P (f) && n == 0)
 13199             {
 13200               /* Window configuration is the same as before.
 13201                  Can do with a display update of the echo area,
 13202                  unless we displayed some mode lines.  */
 13203               update_single_window (w);
 13204               flush_frame (f);
 13205             }
 13206           else
 13207             update_frame (f, true, true);
 13208 
 13209           /* If cursor is in the echo area, make sure that the next
 13210              redisplay displays the minibuffer, so that the cursor will
 13211              be replaced with what the minibuffer wants.  */
 13212           if (cursor_in_echo_area)
 13213             wset_redisplay (XWINDOW (mini_window));
 13214         }
 13215     }
 13216   else if (!EQ (mini_window, selected_window))
 13217     wset_redisplay (XWINDOW (mini_window));
 13218 
 13219   /* Last displayed message is now the current message.  */
 13220   echo_area_buffer[1] = echo_area_buffer[0];
 13221   /* Inform read_char that we're not echoing.  */
 13222   echo_message_buffer = Qnil;
 13223 
 13224   /* Prevent redisplay optimization in redisplay_internal by resetting
 13225      this_line_start_pos.  This is done because the mini-buffer now
 13226      displays the message instead of its buffer text.  */
 13227   if (EQ (mini_window, selected_window))
 13228     CHARPOS (this_line_start_pos) = 0;
 13229 
 13230   if (window_height_changed_p)
 13231     {
 13232       fset_redisplay (f);
 13233 
 13234       /* If window configuration was changed, frames may have been
 13235          marked garbaged.  Clear them or we will experience
 13236          surprises wrt scrolling.
 13237          FIXME: How/why/when?  */
 13238       clear_garbaged_frames ();
 13239     }
 13240 }
 13241 
 13242 /* True if W's buffer was changed but not saved.  */
 13243 
 13244 static bool
 13245 window_buffer_changed (struct window *w)
 13246 {
 13247   struct buffer *b = XBUFFER (w->contents);
 13248 
 13249   eassert (BUFFER_LIVE_P (b));
 13250 
 13251   return (BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)) != w->last_had_star;
 13252 }
 13253 
 13254 /* True if W has %c or %C in its mode line and mode line should be updated.  */
 13255 
 13256 static bool
 13257 mode_line_update_needed (struct window *w)
 13258 {
 13259   return (w->column_number_displayed != -1
 13260           && !(PT == w->last_point && !window_outdated (w))
 13261           && (w->column_number_displayed != current_column ()));
 13262 }
 13263 
 13264 /* True if window start of W is frozen and may not be changed during
 13265    redisplay.  */
 13266 
 13267 static bool
 13268 window_frozen_p (struct window *w)
 13269 {
 13270   if (FRAME_WINDOWS_FROZEN (XFRAME (WINDOW_FRAME (w))))
 13271     {
 13272       Lisp_Object window;
 13273 
 13274       XSETWINDOW (window, w);
 13275       if (MINI_WINDOW_P (w))
 13276         return false;
 13277       else if (EQ (window, selected_window))
 13278         return false;
 13279       else if (MINI_WINDOW_P (XWINDOW (selected_window))
 13280                && EQ (window, Vminibuf_scroll_window))
 13281         /* This special window can't be frozen too.  */
 13282         return false;
 13283       else
 13284         return true;
 13285     }
 13286   return false;
 13287 }
 13288 
 13289 /***********************************************************************
 13290                      Mode Lines and Frame Titles
 13291  ***********************************************************************/
 13292 
 13293 /* A buffer for constructing non-propertized mode-line strings and
 13294    frame titles in it; allocated from the heap in init_xdisp and
 13295    resized as needed in store_mode_line_noprop_char.  */
 13296 
 13297 static char *mode_line_noprop_buf;
 13298 
 13299 /* The buffer's end, and a current output position in it.  */
 13300 
 13301 static char *mode_line_noprop_buf_end;
 13302 static char *mode_line_noprop_ptr;
 13303 
 13304 #define MODE_LINE_NOPROP_LEN(start) \
 13305   ((mode_line_noprop_ptr - mode_line_noprop_buf) - start)
 13306 
 13307 static enum {
 13308   MODE_LINE_DISPLAY = 0,
 13309   MODE_LINE_TITLE,
 13310   MODE_LINE_NOPROP,
 13311   MODE_LINE_STRING
 13312 } mode_line_target;
 13313 
 13314 /* Alist that caches the results of :propertize.
 13315    Each element is (PROPERTIZED-STRING . PROPERTY-LIST).  */
 13316 static Lisp_Object mode_line_proptrans_alist;
 13317 
 13318 /* List of strings making up the mode-line.  */
 13319 static Lisp_Object mode_line_string_list;
 13320 
 13321 /* Base face property when building propertized mode line string.  */
 13322 static Lisp_Object mode_line_string_face;
 13323 static Lisp_Object mode_line_string_face_prop;
 13324 
 13325 
 13326 /* Unwind data for mode line strings */
 13327 
 13328 static Lisp_Object Vmode_line_unwind_vector;
 13329 
 13330 static Lisp_Object
 13331 format_mode_line_unwind_data (struct frame *target_frame,
 13332                               struct buffer *obuf,
 13333                               Lisp_Object owin,
 13334                               bool save_proptrans)
 13335 {
 13336   Lisp_Object vector, tmp;
 13337 
 13338   /* Reduce consing by keeping one vector in
 13339      Vwith_echo_area_save_vector.  */
 13340   vector = Vmode_line_unwind_vector;
 13341   Vmode_line_unwind_vector = Qnil;
 13342 
 13343   if (NILP (vector))
 13344     vector = make_nil_vector (12);
 13345 
 13346   ASET (vector, 0, make_fixnum (mode_line_target));
 13347   ASET (vector, 1, make_fixnum (MODE_LINE_NOPROP_LEN (0)));
 13348   ASET (vector, 2, mode_line_string_list);
 13349   ASET (vector, 3, save_proptrans ? mode_line_proptrans_alist : Qt);
 13350   ASET (vector, 4, mode_line_string_face);
 13351   ASET (vector, 5, mode_line_string_face_prop);
 13352 
 13353   if (obuf)
 13354     XSETBUFFER (tmp, obuf);
 13355   else
 13356     tmp = Qnil;
 13357   ASET (vector, 6, tmp);
 13358   ASET (vector, 7, owin);
 13359   if (target_frame)
 13360     {
 13361       Lisp_Object buffer = XWINDOW (target_frame->selected_window)->contents;
 13362       struct buffer *b = XBUFFER (buffer);
 13363       struct buffer *cb = current_buffer;
 13364 
 13365       /* Similarly to `with-selected-window', if the operation selects
 13366          a window on another frame, we must restore that frame's
 13367          selected window, and (for a tty) the top-frame.  */
 13368       ASET (vector, 8, target_frame->selected_window);
 13369       if (FRAME_TERMCAP_P (target_frame))
 13370         ASET (vector, 9, FRAME_TTY (target_frame)->top_frame);
 13371 
 13372       /* If we select a window on another frame, make sure that that
 13373          selection does not leave its buffer's point modified when
 13374          unwinding (Bug#32777).  */
 13375       ASET (vector, 10, buffer);
 13376       current_buffer = b;
 13377       ASET (vector, 11, build_marker (current_buffer, PT, PT_BYTE));
 13378       current_buffer = cb;
 13379     }
 13380 
 13381   return vector;
 13382 }
 13383 
 13384 static void
 13385 unwind_format_mode_line (Lisp_Object vector)
 13386 {
 13387   Lisp_Object old_window = AREF (vector, 7);
 13388   Lisp_Object target_frame_window = AREF (vector, 8);
 13389   Lisp_Object old_top_frame = AREF (vector, 9);
 13390 
 13391   mode_line_target = XFIXNUM (AREF (vector, 0));
 13392   mode_line_noprop_ptr = mode_line_noprop_buf + XFIXNUM (AREF (vector, 1));
 13393   mode_line_string_list = AREF (vector, 2);
 13394   if (! EQ (AREF (vector, 3), Qt))
 13395     mode_line_proptrans_alist = AREF (vector, 3);
 13396   mode_line_string_face = AREF (vector, 4);
 13397   mode_line_string_face_prop = AREF (vector, 5);
 13398 
 13399   /* Select window before buffer, since it may change the buffer.  */
 13400   if (WINDOW_LIVE_P (old_window))
 13401     {
 13402       /* If the operation that we are unwinding had selected a window
 13403          on a different frame, reset its frame-selected-window.  For a
 13404          text terminal, reset its top-frame if necessary.  */
 13405       if (WINDOW_LIVE_P (target_frame_window))
 13406         {
 13407           Lisp_Object frame
 13408             = WINDOW_FRAME (XWINDOW (target_frame_window));
 13409 
 13410           if (!EQ (frame, WINDOW_FRAME (XWINDOW (old_window))))
 13411             Fselect_window (target_frame_window, Qt);
 13412 
 13413           if (!NILP (old_top_frame) && !EQ (old_top_frame, frame)
 13414               /* This could've been destroyed during the formatting,
 13415                  possibly because the terminal was deleted.  */
 13416               && FRAME_LIVE_P (XFRAME (old_top_frame)))
 13417             Fselect_frame (old_top_frame, Qt);
 13418         }
 13419 
 13420       Fselect_window (old_window, Qt);
 13421 
 13422       /* Restore point of target_frame_window's buffer (Bug#32777).
 13423          But do this only after old_window has been reselected to
 13424          avoid that the window point of target_frame_window moves.  */
 13425       if (WINDOW_LIVE_P (target_frame_window))
 13426         {
 13427           Lisp_Object buffer = AREF (vector, 10);
 13428 
 13429           if (BUFFER_LIVE_P (XBUFFER (buffer)))
 13430             {
 13431               struct buffer *cb = current_buffer;
 13432 
 13433               current_buffer = XBUFFER (buffer);
 13434               set_point_from_marker (AREF (vector, 11));
 13435               ASET (vector, 11, Qnil);
 13436               current_buffer = cb;
 13437             }
 13438         }
 13439     }
 13440 
 13441   if (!NILP (AREF (vector, 6)))
 13442     {
 13443       set_buffer_internal_1 (XBUFFER (AREF (vector, 6)));
 13444       ASET (vector, 6, Qnil);
 13445     }
 13446 
 13447   Vmode_line_unwind_vector = vector;
 13448 }
 13449 
 13450 
 13451 /* Store a single character C for the frame title in mode_line_noprop_buf.
 13452    Re-allocate mode_line_noprop_buf if necessary.  */
 13453 
 13454 static void
 13455 store_mode_line_noprop_char (char c)
 13456 {
 13457   /* If output position has reached the end of the allocated buffer,
 13458      increase the buffer's size.  */
 13459   if (mode_line_noprop_ptr == mode_line_noprop_buf_end)
 13460     {
 13461       ptrdiff_t len = MODE_LINE_NOPROP_LEN (0);
 13462       ptrdiff_t size = len;
 13463       mode_line_noprop_buf =
 13464         xpalloc (mode_line_noprop_buf, &size, 1, STRING_BYTES_BOUND, 1);
 13465       mode_line_noprop_buf_end = mode_line_noprop_buf + size;
 13466       mode_line_noprop_ptr = mode_line_noprop_buf + len;
 13467     }
 13468 
 13469   *mode_line_noprop_ptr++ = c;
 13470 }
 13471 
 13472 
 13473 /* Store part of a frame title in mode_line_noprop_buf, beginning at
 13474    mode_line_noprop_ptr.  STRING is the string to store.  Do not copy
 13475    characters that yield more columns than PRECISION; PRECISION <= 0
 13476    means copy the whole string.  Pad with spaces until FIELD_WIDTH
 13477    number of characters have been copied; FIELD_WIDTH <= 0 means don't
 13478    pad.  Called from display_mode_element when it is used to build a
 13479    frame title.  */
 13480 
 13481 static int
 13482 store_mode_line_noprop (const char *string, int field_width, int precision)
 13483 {
 13484   const unsigned char *str = (const unsigned char *) string;
 13485   int n = 0;
 13486   ptrdiff_t dummy, nbytes;
 13487 
 13488   /* Copy at most PRECISION chars from STR.  */
 13489   nbytes = strlen (string);
 13490   n += c_string_width (str, nbytes, precision, &dummy, &nbytes);
 13491   while (nbytes--)
 13492     store_mode_line_noprop_char (*str++);
 13493 
 13494   /* Fill up with spaces until FIELD_WIDTH reached.  */
 13495   while (field_width > 0
 13496          && n < field_width)
 13497     {
 13498       store_mode_line_noprop_char (' ');
 13499       ++n;
 13500     }
 13501 
 13502   return n;
 13503 }
 13504 
 13505 /***********************************************************************
 13506                              Frame Titles
 13507  ***********************************************************************/
 13508 
 13509 #ifdef HAVE_WINDOW_SYSTEM
 13510 
 13511 /* Set the title of FRAME, if it has changed.  The title format is
 13512    Vicon_title_format if FRAME is iconified, otherwise it is
 13513    frame_title_format.  */
 13514 
 13515 void
 13516 gui_consider_frame_title (Lisp_Object frame)
 13517 {
 13518   struct frame *f = XFRAME (frame);
 13519   Lisp_Object format_data;
 13520 
 13521   if ((FRAME_WINDOW_P (f)
 13522        || FRAME_MINIBUF_ONLY_P (f)
 13523        || f->explicit_name)
 13524       && !FRAME_TOOLTIP_P (f))
 13525     {
 13526       /* Do we have more than one visible frame on this X display?  */
 13527       Lisp_Object tail, other_frame, fmt;
 13528       ptrdiff_t title_start;
 13529       char *title;
 13530       ptrdiff_t len;
 13531       struct it it;
 13532       specpdl_ref count = SPECPDL_INDEX ();
 13533 
 13534       FOR_EACH_FRAME (tail, other_frame)
 13535         {
 13536           struct frame *tf = XFRAME (other_frame);
 13537 
 13538           if (tf != f
 13539               && FRAME_KBOARD (tf) == FRAME_KBOARD (f)
 13540               && !FRAME_MINIBUF_ONLY_P (tf)
 13541               && !FRAME_PARENT_FRAME (tf)
 13542               && !FRAME_TOOLTIP_P (tf)
 13543               && (FRAME_VISIBLE_P (tf) || FRAME_ICONIFIED_P (tf)))
 13544             break;
 13545         }
 13546 
 13547       /* Set global variable indicating that multiple frames exist.  */
 13548       multiple_frames = CONSP (tail);
 13549 
 13550       /* select-frame calls resize_mini_window, which could resize the
 13551          mini-window and by that undo the effect of this redisplay
 13552          cycle wrt minibuffer and echo-area display.  Binding
 13553          inhibit-redisplay to t makes the call to resize_mini_window a
 13554          no-op, thus avoiding the adverse side effects.  */
 13555 
 13556       /* The following was moved before the record_unwind_protect form
 13557          below to inhibit redisplay also when restoring the selected
 13558          window/frame: This avoids that resize_mini_window sizes back
 13559          the minibuffer window of a temporarily selected frame.  See
 13560          Bug#34317.  */
 13561       specbind (Qinhibit_redisplay, Qt);
 13562 
 13563       /* Switch to the buffer of selected window of the frame.  Set up
 13564          mode_line_target so that display_mode_element will output
 13565          into mode_line_noprop_buf; then display the title.  Save the
 13566          original frame and selected window, and possibly the topmost
 13567          frame of the tty (for tty frames) into a vector; it will be
 13568          restored later.  */
 13569 
 13570       format_data = format_mode_line_unwind_data (f, current_buffer,
 13571                                                   selected_window,
 13572                                                   false);
 13573       record_unwind_protect (unwind_format_mode_line, format_data);
 13574 
 13575       Fselect_window (f->selected_window, Qt);
 13576       set_buffer_internal_1 (XBUFFER (XWINDOW (f->selected_window)->contents));
 13577       fmt = (FRAME_ICONIFIED_P (f) && !EQ (Vicon_title_format, Qt)
 13578              ? Vicon_title_format : Vframe_title_format);
 13579 
 13580       mode_line_target = MODE_LINE_TITLE;
 13581       title_start = MODE_LINE_NOPROP_LEN (0);
 13582       init_iterator (&it, XWINDOW (f->selected_window), -1, -1,
 13583                      NULL, DEFAULT_FACE_ID);
 13584       display_mode_element (&it, 0, -1, -1, fmt, Qnil, false);
 13585       len = MODE_LINE_NOPROP_LEN (title_start);
 13586       title = mode_line_noprop_buf + title_start;
 13587       /* Make sure that any raw bytes in the title are properly
 13588          represented by their multibyte sequences.  */
 13589       ptrdiff_t nchars = 0;
 13590       len = str_as_multibyte ((unsigned char *) title,
 13591                               mode_line_noprop_buf_end - title,
 13592                               len, &nchars);
 13593       unbind_to (count, Qnil);
 13594 
 13595       /* Set the title only if it's changed.  This avoids consing in
 13596          the common case where it hasn't.  (If it turns out that we've
 13597          already wasted too much time by walking through the list with
 13598          display_mode_element, then we might need to optimize at a
 13599          higher level than this.)  */
 13600       if ((! STRINGP (f->name)
 13601            || SBYTES (f->name) != len
 13602            || memcmp (title, SDATA (f->name), len) != 0)
 13603           && FRAME_TERMINAL (f)->implicit_set_name_hook)
 13604         {
 13605           Lisp_Object title_string = make_multibyte_string (title, nchars, len);
 13606           FRAME_TERMINAL (f)->implicit_set_name_hook (f, title_string, Qnil);
 13607         }
 13608     }
 13609 }
 13610 
 13611 #endif /* not HAVE_WINDOW_SYSTEM */
 13612 
 13613 
 13614 /***********************************************************************
 13615                               Menu Bars
 13616  ***********************************************************************/
 13617 
 13618 /* True if we will not redisplay all visible windows.  */
 13619 #define REDISPLAY_SOME_P()                              \
 13620   ((windows_or_buffers_changed == 0                     \
 13621     || windows_or_buffers_changed == REDISPLAY_SOME)    \
 13622    && (update_mode_lines == 0                           \
 13623        || update_mode_lines == REDISPLAY_SOME))
 13624 
 13625 static bool
 13626 needs_no_redisplay (struct window *w)
 13627 {
 13628   struct buffer *buffer = XBUFFER (w->contents);
 13629   struct frame *f = XFRAME (w->frame);
 13630   return (REDISPLAY_SOME_P ()
 13631           && !w->redisplay
 13632           && !w->update_mode_line
 13633           && !f->face_change
 13634           && !f->redisplay
 13635           && !buffer->text->redisplay
 13636           && window_point (w) == w->last_point);
 13637 }
 13638 
 13639 /* Prepare for redisplay by updating menu-bar item lists when
 13640    appropriate.  This can call eval.  */
 13641 
 13642 static void
 13643 prepare_menu_bars (void)
 13644 {
 13645   bool all_windows = windows_or_buffers_changed || update_mode_lines;
 13646   bool some_windows = REDISPLAY_SOME_P ();
 13647 
 13648   if (FUNCTIONP (Vpre_redisplay_function))
 13649     {
 13650       Lisp_Object windows = all_windows ? Qt : Qnil;
 13651       if (all_windows && some_windows)
 13652         {
 13653           Lisp_Object ws = window_list ();
 13654           for (windows = Qnil; CONSP (ws); ws = XCDR (ws))
 13655             {
 13656               Lisp_Object this = XCAR (ws);
 13657               struct window *w = XWINDOW (this);
 13658               /* Cf. conditions for redisplaying a window at the
 13659                  beginning of redisplay_window.  */
 13660               if (!needs_no_redisplay (w))
 13661                 windows = Fcons (this, windows);
 13662             }
 13663         }
 13664       safe__call1 (true, Vpre_redisplay_function, windows);
 13665     }
 13666 
 13667   /* Update all frame titles based on their buffer names, etc.  We do
 13668      this before the menu bars so that the buffer-menu will show the
 13669      up-to-date frame titles.  */
 13670 #ifdef HAVE_WINDOW_SYSTEM
 13671   if (all_windows)
 13672     {
 13673       Lisp_Object tail, frame;
 13674 
 13675       FOR_EACH_FRAME (tail, frame)
 13676         {
 13677           struct frame *f = XFRAME (frame);
 13678           struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
 13679           if (some_windows
 13680               && !f->redisplay
 13681               && !w->redisplay
 13682               && !XBUFFER (w->contents)->text->redisplay)
 13683             continue;
 13684 
 13685           if (!FRAME_TOOLTIP_P (f)
 13686               && (FRAME_ICONIFIED_P (f)
 13687                   || FRAME_VISIBLE_P (f) == 1
 13688                   /* Exclude TTY frames that are obscured because they
 13689                      are not the top frame on their console.  This is
 13690                      because gui_consider_frame_title actually switches
 13691                      to the frame, which for TTY frames means it is
 13692                      marked as garbaged, and will be completely
 13693                      redrawn on the next redisplay cycle.  This causes
 13694                      TTY frames to be completely redrawn, when there
 13695                      are more than one of them, even though nothing
 13696                      should be changed on display.  */
 13697                   || (FRAME_REDISPLAY_P (f) && FRAME_WINDOW_P (f))))
 13698             gui_consider_frame_title (frame);
 13699         }
 13700     }
 13701 #endif /* HAVE_WINDOW_SYSTEM */
 13702 
 13703   /* Update the menu bar item lists, if appropriate.  This has to be
 13704      done before any actual redisplay or generation of display lines.  */
 13705 
 13706   if (all_windows)
 13707     {
 13708       Lisp_Object tail, frame;
 13709       specpdl_ref count = SPECPDL_INDEX ();
 13710       /* True means that update_menu_bar has run its hooks
 13711          so any further calls to update_menu_bar shouldn't do so again.  */
 13712       bool menu_bar_hooks_run = false;
 13713 
 13714       record_unwind_save_match_data ();
 13715 
 13716       FOR_EACH_FRAME (tail, frame)
 13717         {
 13718           struct frame *f = XFRAME (frame);
 13719           struct window *w = XWINDOW (FRAME_SELECTED_WINDOW (f));
 13720 
 13721           /* Ignore tooltip frame.  */
 13722           if (FRAME_TOOLTIP_P (f))
 13723             continue;
 13724 
 13725           if (some_windows
 13726               && !f->redisplay
 13727               && !w->redisplay
 13728               && !XBUFFER (w->contents)->text->redisplay)
 13729             continue;
 13730 
 13731           if (!FRAME_PARENT_FRAME (f))
 13732             menu_bar_hooks_run = update_menu_bar (f, false, menu_bar_hooks_run);
 13733 
 13734           update_tab_bar (f, false);
 13735 #ifdef HAVE_WINDOW_SYSTEM
 13736           update_tool_bar (f, false);
 13737 #endif
 13738         }
 13739 
 13740       unbind_to (count, Qnil);
 13741     }
 13742   else
 13743     {
 13744       struct frame *sf = SELECTED_FRAME ();
 13745 
 13746       if (!FRAME_PARENT_FRAME (sf))
 13747         update_menu_bar (sf, true, false);
 13748 
 13749       update_tab_bar (sf, true);
 13750 #ifdef HAVE_WINDOW_SYSTEM
 13751       update_tool_bar (sf, true);
 13752 #endif
 13753     }
 13754 }
 13755 
 13756 
 13757 /* Update the menu bar item list for frame F.  This has to be done
 13758    before we start to fill in any display lines, because it can call
 13759    eval.
 13760 
 13761    If SAVE_MATCH_DATA, we must save and restore it here.
 13762 
 13763    If HOOKS_RUN, a previous call to update_menu_bar
 13764    already ran the menu bar hooks for this redisplay, so there
 13765    is no need to run them again.  The return value is the
 13766    updated value of this flag, to pass to the next call.  */
 13767 
 13768 static bool
 13769 update_menu_bar (struct frame *f, bool save_match_data, bool hooks_run)
 13770 {
 13771   Lisp_Object window;
 13772   struct window *w;
 13773 
 13774   /* If called recursively during a menu update, do nothing.  This can
 13775      happen when, for instance, an activate-menubar-hook causes a
 13776      redisplay.  */
 13777   if (inhibit_menubar_update)
 13778     return hooks_run;
 13779 
 13780   window = FRAME_SELECTED_WINDOW (f);
 13781   w = XWINDOW (window);
 13782 
 13783   if (FRAME_WINDOW_P (f)
 13784       ?
 13785 #ifdef HAVE_EXT_MENU_BAR
 13786       FRAME_EXTERNAL_MENU_BAR (f)
 13787 #else
 13788       FRAME_MENU_BAR_LINES (f) > 0
 13789 #endif
 13790       : FRAME_MENU_BAR_LINES (f) > 0)
 13791     {
 13792       /* If the user has switched buffers or windows, we need to
 13793          recompute to reflect the new bindings.  But we'll
 13794          recompute when update_mode_lines is set too; that means
 13795          that people can use force-mode-line-update to request
 13796          that the menu bar be recomputed.  The adverse effect on
 13797          the rest of the redisplay algorithm is about the same as
 13798          windows_or_buffers_changed anyway.  */
 13799       if (windows_or_buffers_changed
 13800           /* This used to test w->update_mode_line, but we believe
 13801              there is no need to recompute the menu in that case.  */
 13802           || update_mode_lines
 13803           || window_buffer_changed (w))
 13804         {
 13805           struct buffer *prev = current_buffer;
 13806           specpdl_ref count = SPECPDL_INDEX ();
 13807 
 13808           specbind (Qinhibit_menubar_update, Qt);
 13809 
 13810           set_buffer_internal_1 (XBUFFER (w->contents));
 13811           if (save_match_data)
 13812             record_unwind_save_match_data ();
 13813           if (NILP (Voverriding_local_map_menu_flag))
 13814             {
 13815               specbind (Qoverriding_terminal_local_map, Qnil);
 13816               specbind (Qoverriding_local_map, Qnil);
 13817             }
 13818 
 13819           if (!hooks_run)
 13820             {
 13821               /* Run the Lucid hook.  */
 13822               safe_run_hooks (Qactivate_menubar_hook);
 13823 
 13824               /* If it has changed current-menubar from previous value,
 13825                  really recompute the menu-bar from the value.  */
 13826               safe_run_hooks (Qmenu_bar_update_hook);
 13827 
 13828               hooks_run = true;
 13829             }
 13830 
 13831           XSETFRAME (Vmenu_updating_frame, f);
 13832           fset_menu_bar_items (f, menu_bar_items (FRAME_MENU_BAR_ITEMS (f)));
 13833 
 13834           /* Redisplay the menu bar in case we changed it.  */
 13835 #ifdef HAVE_EXT_MENU_BAR
 13836           if (FRAME_WINDOW_P (f))
 13837             {
 13838 #if defined (HAVE_NS)
 13839               /* All frames on Mac OS share the same menubar.  So only
 13840                  the selected frame should be allowed to set it.  */
 13841               if (f == SELECTED_FRAME ())
 13842 #endif
 13843                 set_frame_menubar (f, false);
 13844             }
 13845           else
 13846             /* On a terminal screen, the menu bar is an ordinary screen
 13847                line, and this makes it get updated.  */
 13848             w->update_mode_line = true;
 13849 #else /* ! (HAVE_EXT_MENU_BAR) */
 13850           /* In the non-toolkit version, the menu bar is an ordinary screen
 13851              line, and this makes it get updated.  */
 13852           w->update_mode_line = true;
 13853 #endif /* HAVE_EXT_MENU_BAR */
 13854 
 13855           unbind_to (count, Qnil);
 13856           set_buffer_internal_1 (prev);
 13857         }
 13858     }
 13859 
 13860   return hooks_run;
 13861 }
 13862 
 13863 
 13864 
 13865 /***********************************************************************
 13866                                Tab-bars
 13867  ***********************************************************************/
 13868 
 13869 /* Restore WINDOW as the selected window and its frame as the selected
 13870    frame.  If WINDOW is dead but the selected frame is live, make the
 13871    latter's selected window the selected window.  If both, WINDOW and
 13872    the selected frame, are dead, assign selected frame and window from
 13873    some arbitrary live frame.  Abort if no such frame can be found.  */
 13874 static void
 13875 restore_selected_window (Lisp_Object window)
 13876 {
 13877   if (WINDOW_LIVE_P (window))
 13878     /* If WINDOW is live, make it the selected window and its frame's
 13879        selected window and set the selected frame to its frame.  */
 13880     {
 13881       selected_window = window;
 13882       selected_frame = XWINDOW (window)->frame;
 13883       FRAME_SELECTED_WINDOW (XFRAME (selected_frame)) = window;
 13884     }
 13885   else if (FRAMEP (selected_frame) && FRAME_LIVE_P (XFRAME (selected_frame)))
 13886     /* If WINDOW is dead but the selected frame is still live, make the
 13887        latter's selected window the selected one.  */
 13888     selected_window = FRAME_SELECTED_WINDOW (XFRAME (selected_frame));
 13889   else
 13890     /* If WINDOW and the selected frame are dead, choose some live,
 13891        non-child and non-tooltip frame as the new selected frame and
 13892        make its selected window the selected window.  */
 13893     {
 13894       Lisp_Object tail;
 13895       Lisp_Object frame UNINIT;
 13896 
 13897       FOR_EACH_FRAME (tail, frame)
 13898         {
 13899           struct frame *f = XFRAME (frame);
 13900 
 13901           if (!FRAME_PARENT_FRAME (f) && !FRAME_TOOLTIP_P (f))
 13902             {
 13903               selected_frame = frame;
 13904               selected_window = FRAME_SELECTED_WINDOW (f);
 13905 
 13906               return;
 13907             }
 13908         }
 13909 
 13910       /* Abort if we cannot find a live frame.  */
 13911       emacs_abort ();
 13912     }
 13913 }
 13914 
 13915 /* Restore WINDOW, if live, as its frame's selected window.  */
 13916 static void
 13917 restore_frame_selected_window (Lisp_Object window)
 13918 {
 13919   if (WINDOW_LIVE_P (window))
 13920     /* If WINDOW is live, make it its frame's selected window.  If that
 13921        frame is the selected frame, make WINDOW the selected window as
 13922        well.  */
 13923     {
 13924       Lisp_Object frame = XWINDOW (window)->frame;
 13925 
 13926       FRAME_SELECTED_WINDOW (XFRAME (frame)) = window;
 13927       if (EQ (frame, selected_frame))
 13928         selected_window = window;
 13929     }
 13930 }
 13931 
 13932 /* Update the tab-bar item list for frame F.  This has to be done
 13933    before we start to fill in any display lines.  Called from
 13934    prepare_menu_bars.  If SAVE_MATCH_DATA, we must save
 13935    and restore it here.  */
 13936 
 13937 static void
 13938 update_tab_bar (struct frame *f, bool save_match_data)
 13939 {
 13940   bool do_update = false;
 13941 
 13942 #ifdef HAVE_WINDOW_SYSTEM
 13943   if (FRAME_WINDOW_P (f) && WINDOWP (f->tab_bar_window)) {
 13944     if (WINDOW_TOTAL_LINES (XWINDOW (f->tab_bar_window)) > 0)
 13945       do_update = true;
 13946   }
 13947   else
 13948 #endif
 13949   if (FRAME_TAB_BAR_LINES (f) > 0)
 13950     do_update = true;
 13951 
 13952   if (do_update)
 13953     {
 13954       Lisp_Object window;
 13955       struct window *w;
 13956 
 13957       window = FRAME_SELECTED_WINDOW (f);
 13958       w = XWINDOW (window);
 13959 
 13960       /* If the user has switched buffers or windows, we need to
 13961          recompute to reflect the new bindings.  But we'll
 13962          recompute when update_mode_lines is set too; that means
 13963          that people can use force-mode-line-update to request
 13964          that the menu bar be recomputed.  The adverse effect on
 13965          the rest of the redisplay algorithm is about the same as
 13966          windows_or_buffers_changed anyway.  */
 13967       if (windows_or_buffers_changed
 13968           || w->update_mode_line
 13969           || update_mode_lines
 13970           || window_buffer_changed (w))
 13971         {
 13972           struct buffer *prev = current_buffer;
 13973           specpdl_ref count = SPECPDL_INDEX ();
 13974           Lisp_Object new_tab_bar;
 13975           int new_n_tab_bar;
 13976 
 13977           /* Set current_buffer to the buffer of the selected
 13978              window of the frame, so that we get the right local
 13979              keymaps.  */
 13980           set_buffer_internal_1 (XBUFFER (w->contents));
 13981 
 13982           /* Save match data, if we must.  */
 13983           if (save_match_data)
 13984             record_unwind_save_match_data ();
 13985 
 13986           /* Make sure that we don't accidentally use bogus keymaps.  */
 13987           if (NILP (Voverriding_local_map_menu_flag))
 13988             {
 13989               specbind (Qoverriding_terminal_local_map, Qnil);
 13990               specbind (Qoverriding_local_map, Qnil);
 13991             }
 13992 
 13993           /* We must temporarily set the selected frame to this frame
 13994              before calling tab_bar_items, because the calculation of
 13995              the tab-bar keymap uses the selected frame (see
 13996              `tab-bar-make-keymap' in tab-bar.el).  */
 13997           eassert (EQ (selected_window,
 13998                        /* Since we only explicitly preserve selected_frame,
 13999                           check that selected_window would be redundant.  */
 14000                        XFRAME (selected_frame)->selected_window));
 14001 #ifdef HAVE_WINDOW_SYSTEM
 14002           Lisp_Object frame;
 14003           record_unwind_protect (restore_selected_window, selected_window);
 14004           XSETFRAME (frame, f);
 14005           selected_frame = frame;
 14006           selected_window = FRAME_SELECTED_WINDOW (f);
 14007 #endif
 14008 
 14009           /* Build desired tab-bar items from keymaps.  */
 14010           new_tab_bar
 14011             = tab_bar_items (Fcopy_sequence (f->tab_bar_items),
 14012                               &new_n_tab_bar);
 14013 
 14014           /* Redisplay the tab-bar if we changed it.  */
 14015           if (new_n_tab_bar != f->n_tab_bar_items
 14016               || NILP (Fequal (new_tab_bar, f->tab_bar_items)))
 14017             {
 14018               /* Redisplay that happens asynchronously due to an expose event
 14019                  may access f->tab_bar_items.  Make sure we update both
 14020                  variables within BLOCK_INPUT so no such event interrupts.  */
 14021               block_input ();
 14022               fset_tab_bar_items (f, new_tab_bar);
 14023               f->n_tab_bar_items = new_n_tab_bar;
 14024               w->update_mode_line = true;
 14025               unblock_input ();
 14026             }
 14027 
 14028           unbind_to (count, Qnil);
 14029           set_buffer_internal_1 (prev);
 14030         }
 14031     }
 14032 }
 14033 
 14034 /* Redisplay the tab bar in the frame for window W.
 14035 
 14036    The tab bar of X frames that don't have X toolkit support is
 14037    displayed in a special window W->frame->tab_bar_window.
 14038 
 14039    The tab bar of terminal frames is treated specially as far as
 14040    glyph matrices are concerned.  Tab bar lines are not part of
 14041    windows, so the update is done directly on the frame matrix rows
 14042    for the tab bar.  */
 14043 
 14044 static void
 14045 display_tab_bar (struct window *w)
 14046 {
 14047   struct frame *f = XFRAME (WINDOW_FRAME (w));
 14048   struct it it;
 14049   Lisp_Object items;
 14050   int i;
 14051 
 14052   /* Don't do all this for graphical frames.  */
 14053 #ifdef HAVE_NTGUI
 14054   if (FRAME_W32_P (f))
 14055     return;
 14056 #endif
 14057 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 14058   if (FRAME_X_P (f))
 14059     return;
 14060 #endif
 14061 
 14062 #ifdef HAVE_NS
 14063   if (FRAME_NS_P (f))
 14064     return;
 14065 #endif /* HAVE_NS */
 14066 
 14067 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 14068   eassert (!FRAME_WINDOW_P (f));
 14069   init_iterator (&it, w, -1, -1, f->desired_matrix->rows
 14070                  + (FRAME_MENU_BAR_LINES (f) > 0 ? 1 : 0),
 14071                  TAB_BAR_FACE_ID);
 14072   it.first_visible_x = 0;
 14073   it.last_visible_x = FRAME_PIXEL_WIDTH (f);
 14074 #elif defined (HAVE_X_WINDOWS) /* X without toolkit.  */
 14075   if (FRAME_WINDOW_P (f))
 14076     {
 14077       /* Tab bar lines are displayed in the desired matrix of the
 14078          dummy window tab_bar_window.  */
 14079       struct window *tab_w;
 14080       tab_w = XWINDOW (f->tab_bar_window);
 14081       init_iterator (&it, tab_w, -1, -1, tab_w->desired_matrix->rows,
 14082                      TAB_BAR_FACE_ID);
 14083       it.first_visible_x = 0;
 14084       it.last_visible_x = FRAME_PIXEL_WIDTH (f);
 14085     }
 14086   else
 14087 #endif /* not USE_X_TOOLKIT and not USE_GTK */
 14088     {
 14089       /* This is a TTY frame, i.e. character hpos/vpos are used as
 14090          pixel x/y.  */
 14091       init_iterator (&it, w, -1, -1, f->desired_matrix->rows
 14092                      + (FRAME_MENU_BAR_LINES (f) > 0 ? 1 : 0),
 14093                      TAB_BAR_FACE_ID);
 14094       it.first_visible_x = 0;
 14095       it.last_visible_x = FRAME_COLS (f);
 14096     }
 14097 
 14098   /* FIXME: This should be controlled by a user option.  See the
 14099      comments in redisplay_tool_bar and display_mode_line about
 14100      this.  */
 14101   it.paragraph_embedding = L2R;
 14102 
 14103   /* Clear all rows of the tab bar.  */
 14104   for (i = 0; i < FRAME_TAB_BAR_LINES (f); ++i)
 14105     {
 14106       struct glyph_row *row = it.glyph_row + i;
 14107       clear_glyph_row (row);
 14108       row->enabled_p = true;
 14109       row->full_width_p = true;
 14110       row->reversed_p = false;
 14111     }
 14112 
 14113   /* Display all items of the tab bar.  */
 14114   items = it.f->tab_bar_items;
 14115   int j;
 14116   for (i = 0, j = 0; i < it.f->n_tab_bar_items; ++i, j += TAB_BAR_ITEM_NSLOTS)
 14117     {
 14118       Lisp_Object string = AREF (items, j + TAB_BAR_ITEM_CAPTION);
 14119 
 14120       /* Stop at nil string.  */
 14121       if (NILP (string))
 14122         break;
 14123 
 14124       if (it.current_x < it.last_visible_x)
 14125         display_string (NULL, string, Qnil, 0, 0, &it,
 14126                         SCHARS (string), 0, 0, STRING_MULTIBYTE (string));
 14127     }
 14128 
 14129   /* Fill out the line with spaces.  */
 14130   if (it.current_x < it.last_visible_x)
 14131     display_string ("", Qnil, Qnil, 0, 0, &it, -1, 0, 0, -1);
 14132 
 14133   /* Compute the total height of the lines.  */
 14134   compute_line_metrics (&it);
 14135 }
 14136 
 14137 #ifdef HAVE_WINDOW_SYSTEM
 14138 
 14139 /* Set F->desired_tab_bar_string to a Lisp string representing frame
 14140    F's desired tab-bar contents.  F->tab_bar_items must have
 14141    been set up previously by calling prepare_menu_bars.  */
 14142 
 14143 static void
 14144 build_desired_tab_bar_string (struct frame *f)
 14145 {
 14146   int i;
 14147   Lisp_Object caption;
 14148 
 14149   caption = Qnil;
 14150 
 14151   /* Prepare F->desired_tab_bar_string.  Make a new string.  */
 14152   fset_desired_tab_bar_string (f, build_string (""));
 14153 
 14154   /* Put a `display' property on the string for the captions to display,
 14155      put a `menu_item' property on tab-bar items with a value that
 14156      is the index of the item in F's tab-bar item vector.  */
 14157   for (i = 0; i < f->n_tab_bar_items; ++i)
 14158     {
 14159 #define PROP(IDX) \
 14160   AREF (f->tab_bar_items, i * TAB_BAR_ITEM_NSLOTS + (IDX))
 14161 
 14162       caption = Fcopy_sequence (PROP (TAB_BAR_ITEM_CAPTION));
 14163 
 14164       /* Put a `display' text property on the string for the caption to
 14165          display.  Put a `menu-item' property on the string that gives
 14166          the start of this item's properties in the tab-bar items
 14167          vector.  */
 14168       AUTO_LIST2 (props, Qmenu_item, make_fixnum (i * TAB_BAR_ITEM_NSLOTS));
 14169 
 14170       Fadd_text_properties (make_fixnum (0), make_fixnum (SCHARS (caption)),
 14171                             props, caption);
 14172 
 14173       f->desired_tab_bar_string =
 14174         concat2 (f->desired_tab_bar_string, caption);
 14175 
 14176 #undef PROP
 14177     }
 14178 }
 14179 
 14180 
 14181 /* Display one line of the tab-bar of frame IT->f.
 14182 
 14183    HEIGHT specifies the desired height of the tab-bar line.
 14184    If the actual height of the glyph row is less than HEIGHT, the
 14185    row's height is increased to HEIGHT, and the icons are centered
 14186    vertically in the new height.
 14187 
 14188    If HEIGHT is -1, we are counting needed tab-bar lines, so don't
 14189    count a final empty row in case the tab-bar width exactly matches
 14190    the window width.
 14191 */
 14192 
 14193 static void
 14194 display_tab_bar_line (struct it *it, int height)
 14195 {
 14196   struct glyph_row *row = it->glyph_row;
 14197   int max_x = it->last_visible_x;
 14198   struct glyph *last;
 14199 
 14200   /* Don't extend on a previously drawn tab bar items (Bug#16058).  */
 14201   clear_glyph_row (row);
 14202   row->enabled_p = true;
 14203   row->y = it->current_y;
 14204 
 14205   /* Note that this isn't made use of if the face hasn't a box,
 14206      so there's no need to check the face here.  */
 14207   it->start_of_box_run_p = true;
 14208 
 14209   bool enough = false;
 14210   while (it->current_x < max_x)
 14211     {
 14212       int x, n_glyphs_before, i, nglyphs;
 14213       struct it it_before;
 14214 
 14215       /* Get the next display element.  */
 14216       if (!get_next_display_element (it))
 14217         {
 14218           /* Don't count empty row if we are counting needed tab-bar lines.  */
 14219           if (height < 0 && !it->hpos)
 14220             return;
 14221           break;
 14222         }
 14223 
 14224       /* Produce glyphs.  */
 14225       n_glyphs_before = row->used[TEXT_AREA];
 14226       it_before = *it;
 14227 
 14228       PRODUCE_GLYPHS (it);
 14229 
 14230       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 14231       i = 0;
 14232       x = it_before.current_x;
 14233       while (i < nglyphs)
 14234         {
 14235           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 14236 
 14237           if (x + glyph->pixel_width > max_x)
 14238             {
 14239               /* Glyph doesn't fit on line.  Backtrack.  */
 14240               row->used[TEXT_AREA] = n_glyphs_before;
 14241               *it = it_before;
 14242               /* If this is the only glyph on this line, it will never fit on the
 14243                  tab-bar, so skip it.  But ensure there is at least one glyph,
 14244                  so we don't accidentally disable the tab-bar.  */
 14245               if (n_glyphs_before == 0
 14246                   && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1))
 14247                 break;
 14248               goto out;
 14249             }
 14250 
 14251           ++it->hpos;
 14252           x += glyph->pixel_width;
 14253           ++i;
 14254         }
 14255 
 14256       enough = ITERATOR_AT_END_OF_LINE_P (it);
 14257       set_iterator_to_next (it, true);
 14258 
 14259       /* Stop at line end.  */
 14260       if (enough)
 14261         break;
 14262     }
 14263 
 14264  out:;
 14265 
 14266   row->displays_text_p = row->used[TEXT_AREA] != 0;
 14267 
 14268   /* Use default face for the border below the tab bar.
 14269 
 14270      FIXME: When auto-resize-tab-bars is grow-only, there is
 14271      no additional border below the possibly empty tab-bar lines.
 14272      So to make the extra empty lines look "normal", we have to
 14273      use the tab-bar face for the border too.  */
 14274   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 14275       && !EQ (Vauto_resize_tab_bars, Qgrow_only))
 14276     it->face_id = DEFAULT_FACE_ID;
 14277 
 14278   extend_face_to_end_of_line (it);
 14279   last = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 14280   last->right_box_line_p = true;
 14281   if (last == row->glyphs[TEXT_AREA])
 14282     last->left_box_line_p = true;
 14283 
 14284   /* Make line the desired height and center it vertically.  */
 14285   if ((height -= it->max_ascent + it->max_descent) > 0)
 14286     {
 14287       /* Don't add more than one line height.  */
 14288       height %= FRAME_LINE_HEIGHT (it->f);
 14289       it->max_ascent += height / 2;
 14290       it->max_descent += (height + 1) / 2;
 14291     }
 14292 
 14293   compute_line_metrics (it);
 14294 
 14295   /* If line is empty, make it occupy the rest of the tab-bar.  */
 14296   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row))
 14297     {
 14298       row->height = row->phys_height = it->last_visible_y - row->y;
 14299       row->visible_height = row->height;
 14300       row->ascent = row->phys_ascent = 0;
 14301       row->extra_line_spacing = 0;
 14302     }
 14303 
 14304   row->full_width_p = true;
 14305   row->continued_p = false;
 14306   row->truncated_on_left_p = false;
 14307   row->truncated_on_right_p = false;
 14308 
 14309   it->current_x = it->hpos = 0;
 14310   it->current_y += row->height;
 14311   ++it->vpos;
 14312   ++it->glyph_row;
 14313 }
 14314 
 14315 
 14316 /* Value is the number of pixels needed to make all tab-bar items of
 14317    frame F visible.  The actual number of glyph rows needed is
 14318    returned in *N_ROWS if non-NULL.  */
 14319 static int
 14320 tab_bar_height (struct frame *f, int *n_rows, bool pixelwise)
 14321 {
 14322   struct window *w = XWINDOW (f->tab_bar_window);
 14323   struct it it;
 14324   /* tab_bar_height is called from redisplay_tab_bar after building
 14325      the desired matrix, so use (unused) mode-line row as temporary row to
 14326      avoid destroying the first tab-bar row.  */
 14327   struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
 14328 
 14329   /* Initialize an iterator for iteration over
 14330      F->desired_tab_bar_string in the tab-bar window of frame F.  */
 14331   init_iterator (&it, w, -1, -1, temp_row, TAB_BAR_FACE_ID);
 14332   temp_row->reversed_p = false;
 14333   it.first_visible_x = 0;
 14334   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 14335   reseat_to_string (&it, NULL, f->desired_tab_bar_string,
 14336                     0, 0, 0, STRING_MULTIBYTE (f->desired_tab_bar_string));
 14337   it.paragraph_embedding = L2R;
 14338 
 14339   clear_glyph_row (temp_row);
 14340   while (!ITERATOR_AT_END_P (&it))
 14341     {
 14342       it.glyph_row = temp_row;
 14343       display_tab_bar_line (&it, -1);
 14344     }
 14345   clear_glyph_row (temp_row);
 14346 
 14347   /* f->n_tab_bar_rows == 0 means "unknown"; -1 means no tab-bar.  */
 14348   if (n_rows)
 14349     *n_rows = it.vpos > 0 ? it.vpos : -1;
 14350 
 14351   if (pixelwise)
 14352     return it.current_y;
 14353   else
 14354     return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
 14355 }
 14356 
 14357 DEFUN ("tab-bar-height", Ftab_bar_height, Stab_bar_height,
 14358        0, 2, 0,
 14359        doc: /* Return the number of lines occupied by the tab bar of FRAME.
 14360 If FRAME is nil or omitted, use the selected frame.  Optional argument
 14361 PIXELWISE non-nil means return the height of the tab bar in pixels.  */)
 14362   (Lisp_Object frame, Lisp_Object pixelwise)
 14363 {
 14364   int height = 0;
 14365 
 14366   struct frame *f = decode_any_frame (frame);
 14367 
 14368   if (WINDOWP (f->tab_bar_window)
 14369       && WINDOW_PIXEL_HEIGHT (XWINDOW (f->tab_bar_window)) > 0)
 14370     {
 14371       update_tab_bar (f, true);
 14372       if (f->n_tab_bar_items)
 14373         {
 14374           build_desired_tab_bar_string (f);
 14375           height = tab_bar_height (f, NULL, !NILP (pixelwise));
 14376         }
 14377     }
 14378 
 14379   return make_fixnum (height);
 14380 }
 14381 
 14382 
 14383 /* Display the tab-bar of frame F.  Value is true if tab-bar's
 14384    height should be changed.  */
 14385 static bool
 14386 redisplay_tab_bar (struct frame *f)
 14387 {
 14388   struct window *w;
 14389   struct it it;
 14390   struct glyph_row *row;
 14391 
 14392   f->tab_bar_redisplayed = true;
 14393 
 14394   /* If frame hasn't a tab-bar window or if it is zero-height, don't
 14395      do anything.  This means you must start with tab-bar-lines
 14396      non-zero to get the auto-sizing effect.  Or in other words, you
 14397      can turn off tab-bars by specifying tab-bar-lines zero.  */
 14398   if (!WINDOWP (f->tab_bar_window)
 14399       || (w = XWINDOW (f->tab_bar_window),
 14400           WINDOW_TOTAL_LINES (w) == 0))
 14401     {
 14402       /* Even if we do not display a tab bar initially, still pretend
 14403          that we have resized it.  This avoids that a later activation
 14404          of the tab bar resizes the frame, despite of the fact that the
 14405          setting of 'frame-inhibit-implied-resize' should inhibit it
 14406          (Bug#52986).  */
 14407       f->tab_bar_resized = true;
 14408 
 14409       return false;
 14410     }
 14411 
 14412   /* Build a string that represents the contents of the tab-bar.  */
 14413   build_desired_tab_bar_string (f);
 14414 
 14415   int new_nrows;
 14416   int new_height = tab_bar_height (f, &new_nrows, true);
 14417 
 14418   if (f->n_tab_bar_rows == 0)
 14419     {
 14420       f->n_tab_bar_rows = new_nrows;
 14421       if (new_height != WINDOW_PIXEL_HEIGHT (w))
 14422         frame_default_tab_bar_height = new_height;
 14423     }
 14424 
 14425   /* If new_height or new_nrows indicate that we need to enlarge or
 14426      shrink the tab-bar window, we can return right away.  */
 14427   if (new_nrows > f->n_tab_bar_rows
 14428       || (EQ (Vauto_resize_tab_bars, Qgrow_only)
 14429           && !f->minimize_tab_bar_window_p
 14430           && new_height > WINDOW_PIXEL_HEIGHT (w))
 14431       || (! EQ (Vauto_resize_tab_bars, Qgrow_only)
 14432           && new_height < WINDOW_PIXEL_HEIGHT (w)))
 14433     {
 14434       if (FRAME_TERMINAL (f)->change_tab_bar_height_hook)
 14435         FRAME_TERMINAL (f)->change_tab_bar_height_hook (f, new_height);
 14436       if (new_nrows != f->n_tab_bar_rows)
 14437         f->n_tab_bar_rows = new_nrows;
 14438       clear_glyph_matrix (w->desired_matrix);
 14439       f->fonts_changed = true;
 14440       return true;
 14441     }
 14442 
 14443   /* Set up an iterator for the tab-bar window.  */
 14444   init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TAB_BAR_FACE_ID);
 14445   it.first_visible_x = 0;
 14446   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 14447   row = it.glyph_row;
 14448   row->reversed_p = false;
 14449   reseat_to_string (&it, NULL, f->desired_tab_bar_string, 0, 0, 0,
 14450                     STRING_MULTIBYTE (f->desired_tab_bar_string));
 14451   /* FIXME: This should be controlled by a user option.  But it
 14452      doesn't make sense to have an R2L tab bar if the menu bar cannot
 14453      be drawn also R2L, and making the menu bar R2L is tricky due
 14454      tabkit-specific code that implements it.  If an R2L tab bar is
 14455      ever supported, display_tab_bar_line should also be augmented to
 14456      call unproduce_glyphs like display_line and display_string
 14457      do.  */
 14458   it.paragraph_embedding = L2R;
 14459 
 14460   /* Display as many lines as needed to display all tab-bar items.  */
 14461 
 14462   if (f->n_tab_bar_rows > 0)
 14463     {
 14464       int border, rows, height, extra;
 14465 
 14466       if (TYPE_RANGED_FIXNUMP (int, Vtab_bar_border))
 14467         border = XFIXNUM (Vtab_bar_border);
 14468       else if (EQ (Vtab_bar_border, Qinternal_border_width))
 14469         border = FRAME_INTERNAL_BORDER_WIDTH (f);
 14470       else if (EQ (Vtab_bar_border, Qborder_width))
 14471         border = f->border_width;
 14472       else
 14473         border = 0;
 14474       if (border < 0)
 14475         border = 0;
 14476 
 14477       rows = f->n_tab_bar_rows;
 14478       height = max (1, (it.last_visible_y - border) / rows);
 14479       extra = it.last_visible_y - border - height * rows;
 14480 
 14481       while (it.current_y < it.last_visible_y)
 14482         {
 14483           int h = 0;
 14484           if (extra > 0 && rows-- > 0)
 14485             {
 14486               h = (extra + rows - 1) / rows;
 14487               extra -= h;
 14488             }
 14489           display_tab_bar_line (&it, height + h);
 14490         }
 14491     }
 14492   else
 14493     {
 14494       while (it.current_y < it.last_visible_y)
 14495         display_tab_bar_line (&it, 0);
 14496     }
 14497 
 14498   /* It doesn't make much sense to try scrolling in the tab-bar
 14499      window, so don't do it.  */
 14500   w->desired_matrix->no_scrolling_p = true;
 14501   w->must_be_updated_p = true;
 14502 
 14503   if (!NILP (Vauto_resize_tab_bars))
 14504     {
 14505       bool change_height_p = false;
 14506 
 14507       /* If we couldn't display everything, change the tab-bar's
 14508          height if there is room for more.  */
 14509       if (IT_STRING_CHARPOS (it) < it.end_charpos)
 14510         change_height_p = true;
 14511 
 14512       /* We subtract 1 because display_tab_bar_line advances the
 14513          glyph_row pointer before returning to its caller.  We want to
 14514          examine the last glyph row produced by
 14515          display_tab_bar_line.  */
 14516       row = it.glyph_row - 1;
 14517 
 14518       /* If there are blank lines at the end, except for a partially
 14519          visible blank line at the end that is smaller than
 14520          FRAME_LINE_HEIGHT, change the tab-bar's height.  */
 14521       if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 14522           && row->height >= FRAME_LINE_HEIGHT (f))
 14523         change_height_p = true;
 14524 
 14525       /* If row displays tab-bar items, but is partially visible,
 14526          change the tab-bar's height.  */
 14527       if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
 14528           && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y)
 14529         change_height_p = true;
 14530 
 14531       /* Resize windows as needed by changing the `tab-bar-lines'
 14532          frame parameter.  */
 14533       if (change_height_p)
 14534         {
 14535           int nrows;
 14536           int new_height = tab_bar_height (f, &nrows, true);
 14537 
 14538           change_height_p = ((EQ (Vauto_resize_tab_bars, Qgrow_only)
 14539                               && !f->minimize_tab_bar_window_p)
 14540                              ? (new_height > WINDOW_PIXEL_HEIGHT (w))
 14541                              : (new_height != WINDOW_PIXEL_HEIGHT (w)));
 14542           f->minimize_tab_bar_window_p = false;
 14543 
 14544           if (change_height_p)
 14545             {
 14546               if (FRAME_TERMINAL (f)->change_tab_bar_height_hook)
 14547                 FRAME_TERMINAL (f)->change_tab_bar_height_hook (f, new_height);
 14548               frame_default_tab_bar_height = new_height;
 14549               clear_glyph_matrix (w->desired_matrix);
 14550               f->n_tab_bar_rows = nrows;
 14551               f->fonts_changed = true;
 14552 
 14553               return true;
 14554             }
 14555         }
 14556     }
 14557 
 14558   f->minimize_tab_bar_window_p = false;
 14559   return false;
 14560 }
 14561 
 14562 /* Get information about the tab-bar item which is displayed in GLYPH
 14563    on frame F.  Return in *PROP_IDX the index where tab-bar item
 14564    properties start in F->tab_bar_items.  Return in CLOSE_P an
 14565    indication whether the click was on the close-tab icon of the tab.
 14566    Value is false if GLYPH doesn't display a tab-bar item.  */
 14567 
 14568 static bool
 14569 tab_bar_item_info (struct frame *f, struct glyph *glyph,
 14570                    int *prop_idx, bool *close_p)
 14571 {
 14572   Lisp_Object prop;
 14573   ptrdiff_t charpos;
 14574 
 14575   /* This function can be called asynchronously, which means we must
 14576      exclude any possibility that Fget_text_property signals an
 14577      error.  */
 14578   charpos = min (SCHARS (f->current_tab_bar_string), glyph->charpos);
 14579   charpos = max (0, charpos);
 14580 
 14581   /* Get the text property `menu-item' at pos. The value of that
 14582      property is the start index of this item's properties in
 14583      F->tab_bar_items.  */
 14584   prop = Fget_text_property (make_fixnum (charpos),
 14585                              Qmenu_item, f->current_tab_bar_string);
 14586   if (! FIXNUMP (prop))
 14587     return false;
 14588   *prop_idx = XFIXNUM (prop);
 14589 
 14590   *close_p = !NILP (Fget_text_property (make_fixnum (charpos),
 14591                                         Qclose_tab,
 14592                                         f->current_tab_bar_string));
 14593 
 14594   return true;
 14595 }
 14596 
 14597 
 14598 /* Get information about the tab-bar item at position X/Y on frame F.
 14599    Return in *GLYPH a pointer to the glyph of the tab-bar item in
 14600    the current matrix of the tab-bar window of F, or NULL if not
 14601    on a tab-bar item.  Return in *PROP_IDX the index of the tab-bar
 14602    item in F->tab_bar_items.  Value is
 14603 
 14604    -1   if X/Y is not on a tab-bar item
 14605    0    if X/Y is on the same item that was highlighted before.
 14606    1    otherwise.  */
 14607 
 14608 static int
 14609 get_tab_bar_item (struct frame *f, int x, int y, struct glyph **glyph,
 14610                    int *hpos, int *vpos, int *prop_idx, bool *close_p)
 14611 {
 14612   struct window *w = XWINDOW (f->tab_bar_window);
 14613   int area;
 14614 
 14615   /* Find the glyph under X/Y.  */
 14616   *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, 0, 0, &area);
 14617   if (*glyph == NULL)
 14618     return -1;
 14619 
 14620   /* Get the start of this tab-bar item's properties in
 14621      f->tab_bar_items.  */
 14622   if (!tab_bar_item_info (f, *glyph, prop_idx, close_p))
 14623     return -1;
 14624 
 14625   return *prop_idx == f->last_tab_bar_item ? 0 : 1;
 14626 }
 14627 
 14628 
 14629 /* EXPORT:
 14630    Handle mouse button event on the tab-bar of frame F, at
 14631    frame-relative coordinates X/Y.  DOWN_P is true for a button press,
 14632    false for button release.  MODIFIERS is event modifiers for button
 14633    release.  */
 14634 
 14635 Lisp_Object
 14636 handle_tab_bar_click (struct frame *f, int x, int y, bool down_p,
 14637                       int modifiers)
 14638 {
 14639   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 14640   struct window *w = XWINDOW (f->tab_bar_window);
 14641   int hpos, vpos, prop_idx;
 14642   bool close_p;
 14643   struct glyph *glyph;
 14644   Lisp_Object enabled_p;
 14645   int ts;
 14646 
 14647   frame_to_window_pixel_xy (w, &x, &y);
 14648   ts = get_tab_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx, &close_p);
 14649   if (ts == -1)
 14650     return Fcons (Qtab_bar, Qnil);
 14651 
 14652   /* If item is disabled, do nothing.  */
 14653   enabled_p = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_ENABLED_P);
 14654   if (NILP (enabled_p))
 14655     return Qnil;
 14656 
 14657   if (down_p)
 14658     {
 14659       /* Show the clicked button in pressed state.  */
 14660       if (!NILP (Vmouse_highlight))
 14661         show_mouse_face (hlinfo, DRAW_IMAGE_SUNKEN);
 14662       f->last_tab_bar_item = prop_idx; /* record the pressed tab */
 14663     }
 14664   else
 14665     {
 14666       /* Show item in released state.  */
 14667       if (!NILP (Vmouse_highlight))
 14668         show_mouse_face (hlinfo, DRAW_IMAGE_RAISED);
 14669       f->last_tab_bar_item = -1;
 14670     }
 14671 
 14672   Lisp_Object caption =
 14673     Fcopy_sequence (AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_CAPTION));
 14674 
 14675   AUTO_LIST2 (props, Qmenu_item,
 14676               list3 (AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_KEY),
 14677                      AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_BINDING),
 14678                      close_p ? Qt : Qnil));
 14679 
 14680   Fadd_text_properties (make_fixnum (0), make_fixnum (SCHARS (caption)),
 14681                         props, caption);
 14682 
 14683   return Fcons (Qtab_bar, Fcons (caption, make_fixnum (0)));
 14684 }
 14685 
 14686 
 14687 /* Possibly highlight a tab-bar item on frame F when mouse moves to
 14688    tab-bar window-relative coordinates X/Y.  Called from
 14689    note_mouse_highlight.  */
 14690 
 14691 static void
 14692 note_tab_bar_highlight (struct frame *f, int x, int y)
 14693 {
 14694   Lisp_Object window = f->tab_bar_window;
 14695   struct window *w = XWINDOW (window);
 14696   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 14697   int hpos, vpos;
 14698   struct glyph *glyph;
 14699   struct glyph_row *row;
 14700   int i;
 14701   Lisp_Object enabled_p;
 14702   int prop_idx;
 14703   bool close_p;
 14704   enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
 14705   int rc;
 14706 
 14707   /* Function note_mouse_highlight is called with negative X/Y
 14708      values when mouse moves outside of the frame.  */
 14709   if (x <= 0 || y <= 0)
 14710     {
 14711       clear_mouse_face (hlinfo);
 14712       return;
 14713     }
 14714 
 14715   rc = get_tab_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx, &close_p);
 14716   if (rc < 0)
 14717     {
 14718       /* Not on tab-bar item.  */
 14719       clear_mouse_face (hlinfo);
 14720       return;
 14721     }
 14722   else if (rc == 0)
 14723     /* On same tab-bar item as before.  */
 14724     goto set_help_echo;
 14725 
 14726   clear_mouse_face (hlinfo);
 14727 
 14728   bool mouse_down_p = false;
 14729   /* Mouse is down, but on different tab-bar item?  Or alternatively,
 14730      the mouse might've been pressed somewhere we don't know about,
 14731      and then have moved onto the tab bar.  In this case,
 14732      last_tab_bar_item is -1, so we DTRT and behave like other
 14733      programs by displaying the item as sunken. */
 14734   Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
 14735   mouse_down_p = (gui_mouse_grabbed (dpyinfo)
 14736                   && f == dpyinfo->last_mouse_frame);
 14737 
 14738   if (mouse_down_p && f->last_tab_bar_item != prop_idx
 14739       && f->last_tab_bar_item != -1)
 14740     return;
 14741   draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
 14742 
 14743   /* If tab-bar item is not enabled, don't highlight it.  */
 14744   enabled_p = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_ENABLED_P);
 14745   if (!NILP (enabled_p) && !NILP (Vmouse_highlight))
 14746     {
 14747       /* Compute the x-position of the glyph.  In front and past the
 14748          image is a space.  We include this in the highlighted area.  */
 14749       row = MATRIX_ROW (w->current_matrix, vpos);
 14750       for (i = x = 0; i < hpos; ++i)
 14751         x += row->glyphs[TEXT_AREA][i].pixel_width;
 14752 
 14753       /* Record this as the current active region.  */
 14754       hlinfo->mouse_face_beg_col = hpos;
 14755       hlinfo->mouse_face_beg_row = vpos;
 14756       hlinfo->mouse_face_beg_x = x;
 14757       hlinfo->mouse_face_past_end = false;
 14758 
 14759       hlinfo->mouse_face_end_col = hpos + 1;
 14760       hlinfo->mouse_face_end_row = vpos;
 14761       hlinfo->mouse_face_end_x = x + glyph->pixel_width;
 14762       hlinfo->mouse_face_window = window;
 14763       hlinfo->mouse_face_face_id = TAB_BAR_FACE_ID;
 14764 
 14765       /* Display it as active.  */
 14766       show_mouse_face (hlinfo, draw);
 14767     }
 14768 
 14769  set_help_echo:
 14770 
 14771   /* Set help_echo_string to a help string to display for this tab-bar item.
 14772      XTread_socket does the rest.  */
 14773   help_echo_object = help_echo_window = Qnil;
 14774   help_echo_pos = -1;
 14775   help_echo_string = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_HELP);
 14776   if (NILP (help_echo_string))
 14777     help_echo_string = AREF (f->tab_bar_items, prop_idx + TAB_BAR_ITEM_CAPTION);
 14778 }
 14779 
 14780 #endif /* HAVE_WINDOW_SYSTEM */
 14781 
 14782 /* Find the tab-bar item at X coordinate and return its information.  */
 14783 static Lisp_Object
 14784 tty_get_tab_bar_item (struct frame *f, int x, int *prop_idx, bool *close_p)
 14785 {
 14786   ptrdiff_t clen = 0;
 14787 
 14788   for (int i = 0; i < f->n_tab_bar_items; i++)
 14789     {
 14790       Lisp_Object caption = AREF (f->tab_bar_items, (i * TAB_BAR_ITEM_NSLOTS
 14791                                                      + TAB_BAR_ITEM_CAPTION));
 14792       if (NILP (caption))
 14793         return Qnil;
 14794       clen += SCHARS (caption);
 14795       if (x < clen)
 14796         {
 14797           *prop_idx = i;
 14798           *close_p = !NILP (Fget_text_property (make_fixnum (SCHARS (caption)
 14799                                                              - (clen - x)),
 14800                                                 Qclose_tab,
 14801                                                 caption));
 14802           return caption;
 14803         }
 14804     }
 14805   return Qnil;
 14806 }
 14807 
 14808 /* Handle a mouse click at X/Y on the tab bar of TTY frame F.  If the
 14809    click was on the tab bar and was handled, populate the EVENT
 14810    structure, store it in keyboard queue, and return true; otherwise
 14811    return false.  MODIFIERS are event modifiers for generating the tab
 14812    release event.  */
 14813 Lisp_Object
 14814 tty_handle_tab_bar_click (struct frame *f, int x, int y, bool down_p,
 14815                           struct input_event *event)
 14816 {
 14817   /* Did they click on the tab bar?  */
 14818   if (y < FRAME_MENU_BAR_LINES (f)
 14819       || y >= FRAME_MENU_BAR_LINES (f) + FRAME_TAB_BAR_LINES (f))
 14820     return Qnil;
 14821 
 14822   /* Find the tab-bar item where the X,Y coordinates belong.  */
 14823   int prop_idx;
 14824   bool close_p;
 14825   Lisp_Object caption = tty_get_tab_bar_item (f, x, &prop_idx, &close_p);
 14826 
 14827   if (NILP (caption))
 14828     return Qnil;
 14829 
 14830   if (NILP (AREF (f->tab_bar_items,
 14831                   prop_idx * TAB_BAR_ITEM_NSLOTS + TAB_BAR_ITEM_ENABLED_P)))
 14832     return Qnil;
 14833 
 14834   if (down_p)
 14835     f->last_tab_bar_item = prop_idx;
 14836   else
 14837     f->last_tab_bar_item = -1;
 14838 
 14839   caption = Fcopy_sequence (caption);
 14840 
 14841   AUTO_LIST2 (props, Qmenu_item,
 14842               list3 (AREF (f->tab_bar_items, prop_idx * TAB_BAR_ITEM_NSLOTS
 14843                            + TAB_BAR_ITEM_KEY),
 14844                      AREF (f->tab_bar_items, prop_idx * TAB_BAR_ITEM_NSLOTS
 14845                            + TAB_BAR_ITEM_BINDING),
 14846                      close_p ? Qt : Qnil));
 14847 
 14848   Fadd_text_properties (make_fixnum (0), make_fixnum (SCHARS (caption)),
 14849                         props, caption);
 14850 
 14851   return Fcons (Qtab_bar, Fcons (caption, make_fixnum (0)));
 14852 }
 14853 
 14854 
 14855 
 14856 /***********************************************************************
 14857                                Tool-bars
 14858  ***********************************************************************/
 14859 
 14860 #ifdef HAVE_WINDOW_SYSTEM
 14861 
 14862 /* Update the tool-bar item list for frame F.  This has to be done
 14863    before we start to fill in any display lines.  Called from
 14864    prepare_menu_bars.  If SAVE_MATCH_DATA, we must save
 14865    and restore it here.  */
 14866 
 14867 static void
 14868 update_tool_bar (struct frame *f, bool save_match_data)
 14869 {
 14870 #ifdef HAVE_EXT_TOOL_BAR
 14871   bool do_update = FRAME_EXTERNAL_TOOL_BAR (f);
 14872 #else
 14873   bool do_update = (WINDOWP (f->tool_bar_window)
 14874                     && WINDOW_TOTAL_LINES (XWINDOW (f->tool_bar_window)) > 0);
 14875 #endif
 14876 
 14877   if (do_update)
 14878     {
 14879       Lisp_Object window;
 14880       struct window *w;
 14881 
 14882       window = FRAME_SELECTED_WINDOW (f);
 14883       w = XWINDOW (window);
 14884 
 14885       /* If the user has switched buffers or windows, we need to
 14886          recompute to reflect the new bindings.  But we'll
 14887          recompute when update_mode_lines is set too; that means
 14888          that people can use force-mode-line-update to request
 14889          that the menu bar be recomputed.  The adverse effect on
 14890          the rest of the redisplay algorithm is about the same as
 14891          windows_or_buffers_changed anyway.  */
 14892       if (windows_or_buffers_changed
 14893           || w->update_mode_line
 14894           || update_mode_lines
 14895           || window_buffer_changed (w))
 14896         {
 14897           struct buffer *prev = current_buffer;
 14898           specpdl_ref count = SPECPDL_INDEX ();
 14899           Lisp_Object frame, new_tool_bar;
 14900           int new_n_tool_bar;
 14901 
 14902           /* Set current_buffer to the buffer of the selected
 14903              window of the frame, so that we get the right local
 14904              keymaps.  */
 14905           set_buffer_internal_1 (XBUFFER (w->contents));
 14906 
 14907           /* Save match data, if we must.  */
 14908           if (save_match_data)
 14909             record_unwind_save_match_data ();
 14910 
 14911           /* Make sure that we don't accidentally use bogus keymaps.  */
 14912           if (NILP (Voverriding_local_map_menu_flag))
 14913             {
 14914               specbind (Qoverriding_terminal_local_map, Qnil);
 14915               specbind (Qoverriding_local_map, Qnil);
 14916             }
 14917 
 14918           /* We must temporarily set the selected frame to this frame
 14919              before calling tool_bar_items, because the calculation of
 14920              the tool-bar keymap uses the selected frame (see
 14921              `tool-bar-make-keymap' in tool-bar.el).  */
 14922           eassert (EQ (selected_window,
 14923                        /* Since we only explicitly preserve selected_frame,
 14924                           check that selected_window would be redundant.  */
 14925                        XFRAME (selected_frame)->selected_window));
 14926           record_unwind_protect (restore_selected_window, selected_window);
 14927           XSETFRAME (frame, f);
 14928           selected_frame = frame;
 14929           selected_window = FRAME_SELECTED_WINDOW (f);
 14930 
 14931           /* Build desired tool-bar items from keymaps.  */
 14932           new_tool_bar
 14933             = tool_bar_items (Fcopy_sequence (f->tool_bar_items),
 14934                               &new_n_tool_bar);
 14935 
 14936           /* Redisplay the tool-bar if we changed it.  */
 14937           if (new_n_tool_bar != f->n_tool_bar_items
 14938               || NILP (Fequal (new_tool_bar, f->tool_bar_items)))
 14939             {
 14940               /* Redisplay that happens asynchronously due to an expose event
 14941                  may access f->tool_bar_items.  Make sure we update both
 14942                  variables within BLOCK_INPUT so no such event interrupts.  */
 14943               block_input ();
 14944               fset_tool_bar_items (f, new_tool_bar);
 14945               f->n_tool_bar_items = new_n_tool_bar;
 14946               w->update_mode_line = true;
 14947               unblock_input ();
 14948             }
 14949 
 14950           unbind_to (count, Qnil);
 14951           set_buffer_internal_1 (prev);
 14952         }
 14953     }
 14954 }
 14955 
 14956 #ifndef HAVE_EXT_TOOL_BAR
 14957 
 14958 /* Set F->desired_tool_bar_string to a Lisp string representing frame
 14959    F's desired tool-bar contents.  F->tool_bar_items must have
 14960    been set up previously by calling prepare_menu_bars.  */
 14961 
 14962 static void
 14963 build_desired_tool_bar_string (struct frame *f)
 14964 {
 14965   int i, size, size_needed;
 14966   Lisp_Object image, plist;
 14967 
 14968   image = plist = Qnil;
 14969 
 14970   /* Prepare F->desired_tool_bar_string.  If we can reuse it, do so.
 14971      Otherwise, make a new string.  */
 14972 
 14973   /* The size of the string we might be able to reuse.  */
 14974   size = (STRINGP (f->desired_tool_bar_string)
 14975           ? SCHARS (f->desired_tool_bar_string)
 14976           : 0);
 14977 
 14978   /* We need one space in the string for each image.  */
 14979   size_needed = f->n_tool_bar_items;
 14980 
 14981   /* Reuse f->desired_tool_bar_string, if possible.  */
 14982   if (size < size_needed || NILP (f->desired_tool_bar_string))
 14983     fset_desired_tool_bar_string
 14984       (f, Fmake_string (make_fixnum (size_needed), make_fixnum (' '), Qnil));
 14985   else
 14986     {
 14987       AUTO_LIST4 (props, Qdisplay, Qnil, Qmenu_item, Qnil);
 14988       Fremove_text_properties (make_fixnum (0), make_fixnum (size),
 14989                                props, f->desired_tool_bar_string);
 14990     }
 14991 
 14992   /* Put a `display' property on the string for the images to display,
 14993      put a `menu_item' property on tool-bar items with a value that
 14994      is the index of the item in F's tool-bar item vector.  */
 14995   for (i = 0; i < f->n_tool_bar_items; ++i)
 14996     {
 14997 #define PROP(IDX) \
 14998   AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
 14999 
 15000       bool enabled_p = !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P));
 15001       bool selected_p = !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P));
 15002       int hmargin, vmargin, relief, idx, end;
 15003 
 15004       /* If image is a vector, choose the image according to the
 15005          button state.  */
 15006       image = PROP (TOOL_BAR_ITEM_IMAGES);
 15007       if (VECTORP (image))
 15008         {
 15009           if (enabled_p)
 15010             idx = (selected_p
 15011                    ? TOOL_BAR_IMAGE_ENABLED_SELECTED
 15012                    : TOOL_BAR_IMAGE_ENABLED_DESELECTED);
 15013           else
 15014             idx = (selected_p
 15015                    ? TOOL_BAR_IMAGE_DISABLED_SELECTED
 15016                    : TOOL_BAR_IMAGE_DISABLED_DESELECTED);
 15017 
 15018           eassert (ASIZE (image) >= idx);
 15019           image = AREF (image, idx);
 15020         }
 15021       else
 15022         idx = -1;
 15023 
 15024       /* Ignore invalid image specifications.  */
 15025       if (!valid_image_p (image))
 15026         continue;
 15027 
 15028       /* Display the tool-bar button pressed, or depressed.  */
 15029       plist = Fcopy_sequence (XCDR (image));
 15030 
 15031       /* Compute margin and relief to draw.  */
 15032       relief = (tool_bar_button_relief >= 0
 15033                 ? min (tool_bar_button_relief,
 15034                        min (INT_MAX, MOST_POSITIVE_FIXNUM))
 15035                 : DEFAULT_TOOL_BAR_BUTTON_RELIEF);
 15036       hmargin = vmargin = relief;
 15037 
 15038       if (RANGED_FIXNUMP (1, Vtool_bar_button_margin,
 15039                            INT_MAX - max (hmargin, vmargin)))
 15040         {
 15041           hmargin += XFIXNAT (Vtool_bar_button_margin);
 15042           vmargin += XFIXNAT (Vtool_bar_button_margin);
 15043         }
 15044       else if (CONSP (Vtool_bar_button_margin))
 15045         {
 15046           if (RANGED_FIXNUMP (1, XCAR (Vtool_bar_button_margin),
 15047                                INT_MAX - hmargin))
 15048             hmargin += XFIXNAT (XCAR (Vtool_bar_button_margin));
 15049 
 15050           if (RANGED_FIXNUMP (1, XCDR (Vtool_bar_button_margin),
 15051                                INT_MAX - vmargin))
 15052             vmargin += XFIXNAT (XCDR (Vtool_bar_button_margin));
 15053         }
 15054 
 15055       if (auto_raise_tool_bar_buttons_p)
 15056         {
 15057           /* Add a `:relief' property to the image spec if the item is
 15058              selected.  */
 15059           if (selected_p)
 15060             {
 15061               plist = plist_put (plist, QCrelief, make_fixnum (-relief));
 15062               hmargin -= relief;
 15063               vmargin -= relief;
 15064             }
 15065         }
 15066       else
 15067         {
 15068           /* If image is selected, display it pressed, i.e. with a
 15069              negative relief.  If it's not selected, display it with a
 15070              raised relief.  */
 15071           plist = plist_put (plist, QCrelief,
 15072                              (selected_p
 15073                               ? make_fixnum (-relief)
 15074                               : make_fixnum (relief)));
 15075           hmargin -= relief;
 15076           vmargin -= relief;
 15077         }
 15078 
 15079       /* Put a margin around the image.  */
 15080       if (hmargin || vmargin)
 15081         {
 15082           if (hmargin == vmargin)
 15083             plist = plist_put (plist, QCmargin, make_fixnum (hmargin));
 15084           else
 15085             plist = plist_put (plist, QCmargin,
 15086                                Fcons (make_fixnum (hmargin),
 15087                                       make_fixnum (vmargin)));
 15088         }
 15089 
 15090       /* If button is not enabled, and we don't have special images
 15091          for the disabled state, make the image appear disabled by
 15092          applying an appropriate algorithm to it.  */
 15093       if (!enabled_p && idx < 0)
 15094         plist = plist_put (plist, QCconversion, Qdisabled);
 15095 
 15096       /* Put a `display' text property on the string for the image to
 15097          display.  Put a `menu-item' property on the string that gives
 15098          the start of this item's properties in the tool-bar items
 15099          vector.  */
 15100       image = Fcons (Qimage, plist);
 15101       AUTO_LIST4 (props, Qdisplay, image, Qmenu_item,
 15102                   make_fixnum (i * TOOL_BAR_ITEM_NSLOTS));
 15103 
 15104       /* Let the last image hide all remaining spaces in the tool bar
 15105          string.  The string can be longer than needed when we reuse a
 15106          previous string.  */
 15107       if (i + 1 == f->n_tool_bar_items)
 15108         end = SCHARS (f->desired_tool_bar_string);
 15109       else
 15110         end = i + 1;
 15111       Fadd_text_properties (make_fixnum (i), make_fixnum (end),
 15112                             props, f->desired_tool_bar_string);
 15113 #undef PROP
 15114     }
 15115 }
 15116 
 15117 
 15118 /* Display one line of the tool-bar of frame IT->f.
 15119 
 15120    HEIGHT specifies the desired height of the tool-bar line.
 15121    If the actual height of the glyph row is less than HEIGHT, the
 15122    row's height is increased to HEIGHT, and the icons are centered
 15123    vertically in the new height.
 15124 
 15125    If HEIGHT is -1, we are counting needed tool-bar lines, so don't
 15126    count a final empty row in case the tool-bar width exactly matches
 15127    the window width.
 15128 */
 15129 
 15130 static void
 15131 display_tool_bar_line (struct it *it, int height)
 15132 {
 15133   struct glyph_row *row = it->glyph_row;
 15134   int max_x = it->last_visible_x;
 15135   struct glyph *last;
 15136 
 15137   /* Don't extend on a previously drawn tool bar items (Bug#16058).  */
 15138   clear_glyph_row (row);
 15139   row->enabled_p = true;
 15140   row->y = it->current_y;
 15141 
 15142   /* Note that this isn't made use of if the face hasn't a box,
 15143      so there's no need to check the face here.  */
 15144   it->start_of_box_run_p = true;
 15145 
 15146   while (it->current_x < max_x)
 15147     {
 15148       int x, n_glyphs_before, i, nglyphs;
 15149       struct it it_before;
 15150 
 15151       /* Get the next display element.  */
 15152       if (!get_next_display_element (it))
 15153         {
 15154           /* Don't count empty row if we are counting needed tool-bar lines.  */
 15155           if (height < 0 && !it->hpos)
 15156             return;
 15157           break;
 15158         }
 15159 
 15160       /* Produce glyphs.  */
 15161       n_glyphs_before = row->used[TEXT_AREA];
 15162       it_before = *it;
 15163 
 15164       PRODUCE_GLYPHS (it);
 15165 
 15166       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 15167       i = 0;
 15168       x = it_before.current_x;
 15169       while (i < nglyphs)
 15170         {
 15171           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 15172 
 15173           if (x + glyph->pixel_width > max_x)
 15174             {
 15175               /* Glyph doesn't fit on line.  Backtrack.  */
 15176               row->used[TEXT_AREA] = n_glyphs_before;
 15177               *it = it_before;
 15178               /* If this is the only glyph on this line, it will never fit on the
 15179                  tool-bar, so skip it.  But ensure there is at least one glyph,
 15180                  so we don't accidentally disable the tool-bar.  */
 15181               if (n_glyphs_before == 0
 15182                   && (it->vpos > 0 || IT_STRING_CHARPOS (*it) < it->end_charpos-1))
 15183                 break;
 15184               goto out;
 15185             }
 15186 
 15187           ++it->hpos;
 15188           x += glyph->pixel_width;
 15189           ++i;
 15190         }
 15191 
 15192       /* Stop at line end.  */
 15193       if (ITERATOR_AT_END_OF_LINE_P (it))
 15194         break;
 15195 
 15196       set_iterator_to_next (it, true);
 15197     }
 15198 
 15199  out:;
 15200 
 15201   row->displays_text_p = row->used[TEXT_AREA] != 0;
 15202 
 15203   /* Use default face for the border below the tool bar.
 15204 
 15205      FIXME: When auto-resize-tool-bars is grow-only, there is
 15206      no additional border below the possibly empty tool-bar lines.
 15207      So to make the extra empty lines look "normal", we have to
 15208      use the tool-bar face for the border too.  */
 15209   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 15210       && !EQ (Vauto_resize_tool_bars, Qgrow_only))
 15211     it->face_id = DEFAULT_FACE_ID;
 15212 
 15213   extend_face_to_end_of_line (it);
 15214   last = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 15215   last->right_box_line_p = true;
 15216   if (last == row->glyphs[TEXT_AREA])
 15217     last->left_box_line_p = true;
 15218 
 15219   /* Make line the desired height and center it vertically.  */
 15220   if ((height -= it->max_ascent + it->max_descent) > 0)
 15221     {
 15222       /* Don't add more than one line height.  */
 15223       height %= FRAME_LINE_HEIGHT (it->f);
 15224       it->max_ascent += height / 2;
 15225       it->max_descent += (height + 1) / 2;
 15226     }
 15227 
 15228   compute_line_metrics (it);
 15229 
 15230   /* If line is empty, make it occupy the rest of the tool-bar.  */
 15231   if (!MATRIX_ROW_DISPLAYS_TEXT_P (row))
 15232     {
 15233       row->height = row->phys_height = it->last_visible_y - row->y;
 15234       row->visible_height = row->height;
 15235       row->ascent = row->phys_ascent = 0;
 15236       row->extra_line_spacing = 0;
 15237     }
 15238 
 15239   row->full_width_p = true;
 15240   row->continued_p = false;
 15241   row->truncated_on_left_p = false;
 15242   row->truncated_on_right_p = false;
 15243 
 15244   it->current_x = it->hpos = 0;
 15245   it->current_y += row->height;
 15246   ++it->vpos;
 15247   ++it->glyph_row;
 15248 }
 15249 
 15250 
 15251 /* Value is the number of pixels needed to make all tool-bar items of
 15252    frame F visible.  The actual number of glyph rows needed is
 15253    returned in *N_ROWS if non-NULL.  */
 15254 static int
 15255 tool_bar_height (struct frame *f, int *n_rows, bool pixelwise)
 15256 {
 15257   struct window *w = XWINDOW (f->tool_bar_window);
 15258   struct it it;
 15259   /* tool_bar_height is called from redisplay_tool_bar after building
 15260      the desired matrix, so use (unused) mode-line row as temporary row to
 15261      avoid destroying the first tool-bar row.  */
 15262   struct glyph_row *temp_row = MATRIX_MODE_LINE_ROW (w->desired_matrix);
 15263 
 15264   /* Initialize an iterator for iteration over
 15265      F->desired_tool_bar_string in the tool-bar window of frame F.  */
 15266   init_iterator (&it, w, -1, -1, temp_row, TOOL_BAR_FACE_ID);
 15267   temp_row->reversed_p = false;
 15268   it.first_visible_x = 0;
 15269   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 15270   reseat_to_string (&it, NULL, f->desired_tool_bar_string,
 15271                     0, 0, 0, STRING_MULTIBYTE (f->desired_tool_bar_string));
 15272   it.paragraph_embedding = L2R;
 15273 
 15274   while (!ITERATOR_AT_END_P (&it))
 15275     {
 15276       clear_glyph_row (temp_row);
 15277       it.glyph_row = temp_row;
 15278       display_tool_bar_line (&it, -1);
 15279     }
 15280   clear_glyph_row (temp_row);
 15281 
 15282   /* f->n_tool_bar_rows == 0 means "unknown"; -1 means no tool-bar.  */
 15283   if (n_rows)
 15284     *n_rows = it.vpos > 0 ? it.vpos : -1;
 15285 
 15286   if (pixelwise)
 15287     return it.current_y;
 15288   else
 15289     return (it.current_y + FRAME_LINE_HEIGHT (f) - 1) / FRAME_LINE_HEIGHT (f);
 15290 }
 15291 
 15292 #endif /* ! (HAVE_EXT_TOOL_BAR) */
 15293 
 15294 DEFUN ("tool-bar-height", Ftool_bar_height, Stool_bar_height,
 15295        0, 2, 0,
 15296        doc: /* Return the number of lines occupied by the tool bar of FRAME.
 15297 If FRAME is nil or omitted, use the selected frame.  Optional argument
 15298 PIXELWISE non-nil means return the height of the tool bar in pixels.  */)
 15299   (Lisp_Object frame, Lisp_Object pixelwise)
 15300 {
 15301   int height = 0;
 15302 
 15303 #ifndef HAVE_EXT_TOOL_BAR
 15304   struct frame *f = decode_any_frame (frame);
 15305 
 15306   if (WINDOWP (f->tool_bar_window)
 15307       && WINDOW_PIXEL_HEIGHT (XWINDOW (f->tool_bar_window)) > 0)
 15308     {
 15309       update_tool_bar (f, true);
 15310       if (f->n_tool_bar_items)
 15311         {
 15312           build_desired_tool_bar_string (f);
 15313           height = tool_bar_height (f, NULL, !NILP (pixelwise));
 15314         }
 15315     }
 15316 #endif
 15317 
 15318   return make_fixnum (height);
 15319 }
 15320 
 15321 #ifndef HAVE_EXT_TOOL_BAR
 15322 
 15323 /* Display the internal tool-bar of frame F.  Value is true if
 15324    tool-bar's height should be changed.  */
 15325 static bool
 15326 redisplay_tool_bar (struct frame *f)
 15327 {
 15328   struct window *w;
 15329   struct it it;
 15330   struct glyph_row *row;
 15331 
 15332   f->tool_bar_redisplayed = true;
 15333 
 15334   /* If frame hasn't a tool-bar window or if it is zero-height, don't
 15335      do anything.  This means you must start with tool-bar-lines
 15336      non-zero to get the auto-sizing effect.  Or in other words, you
 15337      can turn off tool-bars by specifying tool-bar-lines zero.  */
 15338   if (!WINDOWP (f->tool_bar_window)
 15339       || (w = XWINDOW (f->tool_bar_window),
 15340           WINDOW_TOTAL_LINES (w) == 0))
 15341     {
 15342       /* Even if we do not display a tool bar initially, still pretend
 15343          that we have resized it already.  This avoids that a later
 15344          activation of the tool bar resizes the frame, despite of the
 15345          fact that a setting of 'frame-inhibit-implied-resize' should
 15346          inhibit it (Bug#52986).  */
 15347       f->tool_bar_resized = true;
 15348 
 15349       return false;
 15350     }
 15351 
 15352   /* Set up an iterator for the tool-bar window.  */
 15353   init_iterator (&it, w, -1, -1, w->desired_matrix->rows, TOOL_BAR_FACE_ID);
 15354   it.first_visible_x = 0;
 15355   it.last_visible_x = WINDOW_PIXEL_WIDTH (w);
 15356   row = it.glyph_row;
 15357   row->reversed_p = false;
 15358 
 15359   /* Build a string that represents the contents of the tool-bar.  */
 15360   build_desired_tool_bar_string (f);
 15361   reseat_to_string (&it, NULL, f->desired_tool_bar_string,
 15362                     0, 0, 0, STRING_MULTIBYTE (f->desired_tool_bar_string));
 15363   /* FIXME: This should be controlled by a user option.  But it
 15364      doesn't make sense to have an R2L tool bar if the menu bar cannot
 15365      be drawn also R2L, and making the menu bar R2L is tricky due to
 15366      toolkit-specific code that implements it.  If an R2L tool bar is
 15367      ever supported, display_tool_bar_line should also be augmented to
 15368      call unproduce_glyphs like display_line and display_string
 15369      do.  */
 15370   it.paragraph_embedding = L2R;
 15371 
 15372   if (f->n_tool_bar_rows == 0)
 15373     {
 15374       int new_height = tool_bar_height (f, &f->n_tool_bar_rows, true);
 15375 
 15376       if (new_height != WINDOW_PIXEL_HEIGHT (w))
 15377         {
 15378           if (FRAME_TERMINAL (f)->change_tool_bar_height_hook)
 15379             FRAME_TERMINAL (f)->change_tool_bar_height_hook (f, new_height);
 15380           frame_default_tool_bar_height = new_height;
 15381           /* Always do that now.  */
 15382           clear_glyph_matrix (w->desired_matrix);
 15383           f->fonts_changed = true;
 15384           return true;
 15385         }
 15386     }
 15387 
 15388   /* Display as many lines as needed to display all tool-bar items.  */
 15389 
 15390   if (f->n_tool_bar_rows > 0)
 15391     {
 15392       int border, rows, height, extra;
 15393 
 15394       if (TYPE_RANGED_FIXNUMP (int, Vtool_bar_border))
 15395         border = XFIXNUM (Vtool_bar_border);
 15396       else if (EQ (Vtool_bar_border, Qinternal_border_width))
 15397         border = FRAME_INTERNAL_BORDER_WIDTH (f);
 15398       else if (EQ (Vtool_bar_border, Qborder_width))
 15399         border = f->border_width;
 15400       else
 15401         border = 0;
 15402       if (border < 0)
 15403         border = 0;
 15404 
 15405       rows = f->n_tool_bar_rows;
 15406       height = max (1, (it.last_visible_y - border) / rows);
 15407       extra = it.last_visible_y - border - height * rows;
 15408 
 15409       while (it.current_y < it.last_visible_y)
 15410         {
 15411           int h = 0;
 15412           if (extra > 0 && rows-- > 0)
 15413             {
 15414               h = (extra + rows - 1) / rows;
 15415               extra -= h;
 15416             }
 15417           display_tool_bar_line (&it, height + h);
 15418         }
 15419     }
 15420   else
 15421     {
 15422       while (it.current_y < it.last_visible_y)
 15423         display_tool_bar_line (&it, 0);
 15424     }
 15425 
 15426   /* It doesn't make much sense to try scrolling in the tool-bar
 15427      window, so don't do it.  */
 15428   w->desired_matrix->no_scrolling_p = true;
 15429   w->must_be_updated_p = true;
 15430 
 15431   if (!NILP (Vauto_resize_tool_bars))
 15432     {
 15433       bool change_height_p = false;
 15434 
 15435       /* If we couldn't display everything, change the tool-bar's
 15436          height if there is room for more.  */
 15437       if (IT_STRING_CHARPOS (it) < it.end_charpos)
 15438         change_height_p = true;
 15439 
 15440       /* We subtract 1 because display_tool_bar_line advances the
 15441          glyph_row pointer before returning to its caller.  We want to
 15442          examine the last glyph row produced by
 15443          display_tool_bar_line.  */
 15444       row = it.glyph_row - 1;
 15445 
 15446       /* If there are blank lines at the end, except for a partially
 15447          visible blank line at the end that is smaller than
 15448          FRAME_LINE_HEIGHT, change the tool-bar's height.  */
 15449       if (!MATRIX_ROW_DISPLAYS_TEXT_P (row)
 15450           && row->height >= FRAME_LINE_HEIGHT (f))
 15451         change_height_p = true;
 15452 
 15453       /* If row displays tool-bar items, but is partially visible,
 15454          change the tool-bar's height.  */
 15455       if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
 15456           && MATRIX_ROW_BOTTOM_Y (row) > it.last_visible_y)
 15457         change_height_p = true;
 15458 
 15459       /* Resize windows as needed by changing the `tool-bar-lines'
 15460          frame parameter.  */
 15461       if (change_height_p)
 15462         {
 15463           int nrows;
 15464           int new_height = tool_bar_height (f, &nrows, true);
 15465 
 15466           change_height_p = ((EQ (Vauto_resize_tool_bars, Qgrow_only)
 15467                               && !f->minimize_tool_bar_window_p)
 15468                              ? (new_height > WINDOW_PIXEL_HEIGHT (w))
 15469                              : (new_height != WINDOW_PIXEL_HEIGHT (w)));
 15470           f->minimize_tool_bar_window_p = false;
 15471 
 15472           if (change_height_p)
 15473             {
 15474               if (FRAME_TERMINAL (f)->change_tool_bar_height_hook)
 15475                 FRAME_TERMINAL (f)->change_tool_bar_height_hook (f, new_height);
 15476               frame_default_tool_bar_height = new_height;
 15477               clear_glyph_matrix (w->desired_matrix);
 15478               f->n_tool_bar_rows = nrows;
 15479               f->fonts_changed = true;
 15480 
 15481               return true;
 15482             }
 15483         }
 15484     }
 15485 
 15486   f->minimize_tool_bar_window_p = false;
 15487 
 15488   return false;
 15489 }
 15490 
 15491 /* Get information about the tool-bar item which is displayed in GLYPH
 15492    on frame F.  Return in *PROP_IDX the index where tool-bar item
 15493    properties start in F->tool_bar_items.  Value is false if
 15494    GLYPH doesn't display a tool-bar item.  */
 15495 
 15496 static bool
 15497 tool_bar_item_info (struct frame *f, struct glyph *glyph, int *prop_idx)
 15498 {
 15499   Lisp_Object prop;
 15500   ptrdiff_t charpos;
 15501 
 15502   /* This function can be called asynchronously, which means we must
 15503      exclude any possibility that Fget_text_property signals an
 15504      error.  */
 15505   charpos = min (SCHARS (f->current_tool_bar_string), glyph->charpos);
 15506   charpos = max (0, charpos);
 15507 
 15508   /* Get the text property `menu-item' at pos. The value of that
 15509      property is the start index of this item's properties in
 15510      F->tool_bar_items.  */
 15511   prop = Fget_text_property (make_fixnum (charpos),
 15512                              Qmenu_item, f->current_tool_bar_string);
 15513   if (! FIXNUMP (prop))
 15514     return false;
 15515   *prop_idx = XFIXNUM (prop);
 15516   return true;
 15517 }
 15518 
 15519 
 15520 /* Get information about the tool-bar item at position X/Y on frame F.
 15521    Return in *GLYPH a pointer to the glyph of the tool-bar item in
 15522    the current matrix of the tool-bar window of F, or NULL if not
 15523    on a tool-bar item.  Return in *PROP_IDX the index of the tool-bar
 15524    item in F->tool_bar_items.  Value is
 15525 
 15526    -1   if X/Y is not on a tool-bar item
 15527    0    if X/Y is on the same item that was highlighted before.
 15528    1    otherwise.  */
 15529 
 15530 static int
 15531 get_tool_bar_item (struct frame *f, int x, int y, struct glyph **glyph,
 15532                    int *hpos, int *vpos, int *prop_idx)
 15533 {
 15534   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 15535   struct window *w = XWINDOW (f->tool_bar_window);
 15536   int area;
 15537 
 15538   /* Find the glyph under X/Y.  */
 15539   *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, 0, 0, &area);
 15540   if (*glyph == NULL)
 15541     return -1;
 15542 
 15543   /* Get the start of this tool-bar item's properties in
 15544      f->tool_bar_items.  */
 15545   if (!tool_bar_item_info (f, *glyph, prop_idx))
 15546     return -1;
 15547 
 15548   /* Is mouse on the highlighted item?  */
 15549   if (EQ (f->tool_bar_window, hlinfo->mouse_face_window)
 15550       && *vpos >= hlinfo->mouse_face_beg_row
 15551       && *vpos <= hlinfo->mouse_face_end_row
 15552       && (*vpos > hlinfo->mouse_face_beg_row
 15553           || *hpos >= hlinfo->mouse_face_beg_col)
 15554       && (*vpos < hlinfo->mouse_face_end_row
 15555           || *hpos < hlinfo->mouse_face_end_col
 15556           || hlinfo->mouse_face_past_end))
 15557     return 0;
 15558 
 15559   return 1;
 15560 }
 15561 
 15562 
 15563 /* EXPORT:
 15564    Handle mouse button event on the tool-bar of frame F, at
 15565    frame-relative coordinates X/Y.  DOWN_P is true for a button press,
 15566    false for button release.  MODIFIERS is event modifiers for button
 15567    release.  DEVICE is the device the click came from, or Qt.  */
 15568 
 15569 void
 15570 handle_tool_bar_click_with_device (struct frame *f, int x, int y, bool down_p,
 15571                                    int modifiers, Lisp_Object device)
 15572 {
 15573   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 15574   struct window *w = XWINDOW (f->tool_bar_window);
 15575   int hpos, vpos, prop_idx;
 15576   struct glyph *glyph;
 15577   Lisp_Object enabled_p;
 15578   int ts;
 15579 
 15580   /* If not on the highlighted tool-bar item, and mouse-highlight is
 15581      non-nil, return.  This is so we generate the tool-bar button
 15582      click only when the mouse button is released on the same item as
 15583      where it was pressed.  However, when mouse-highlight is disabled,
 15584      generate the click when the button is released regardless of the
 15585      highlight, since tool-bar items are not highlighted in that
 15586      case.  */
 15587   frame_to_window_pixel_xy (w, &x, &y);
 15588   ts = get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
 15589   if (ts == -1
 15590       || (ts != 0 && !NILP (Vmouse_highlight)))
 15591     return;
 15592 
 15593   /* When mouse-highlight is off, generate the click for the item
 15594      where the button was pressed, disregarding where it was
 15595      released.  */
 15596   if (NILP (Vmouse_highlight) && !down_p)
 15597     prop_idx = f->last_tool_bar_item;
 15598 
 15599   /* If item is disabled, do nothing.  */
 15600   enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
 15601   if (NILP (enabled_p))
 15602     return;
 15603 
 15604   if (down_p)
 15605     {
 15606       /* Show item in pressed state.  */
 15607       if (!NILP (Vmouse_highlight))
 15608         show_mouse_face (hlinfo, DRAW_IMAGE_SUNKEN);
 15609       f->last_tool_bar_item = prop_idx;
 15610     }
 15611   else
 15612     {
 15613       Lisp_Object key, frame;
 15614       struct input_event event;
 15615       EVENT_INIT (event);
 15616 
 15617       /* Show item in released state.  */
 15618       if (!NILP (Vmouse_highlight))
 15619         show_mouse_face (hlinfo, DRAW_IMAGE_RAISED);
 15620 
 15621       key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
 15622 
 15623       XSETFRAME (frame, f);
 15624       event.kind = TOOL_BAR_EVENT;
 15625       event.frame_or_window = frame;
 15626       event.arg = key;
 15627       event.modifiers = modifiers;
 15628       event.device = device;
 15629       kbd_buffer_store_event (&event);
 15630       f->last_tool_bar_item = -1;
 15631     }
 15632 }
 15633 
 15634 void
 15635 handle_tool_bar_click (struct frame *f, int x, int y, bool down_p,
 15636                        int modifiers)
 15637 {
 15638   handle_tool_bar_click_with_device (f, x, y, down_p, modifiers, Qt);
 15639 }
 15640 
 15641 /* Possibly highlight a tool-bar item on frame F when mouse moves to
 15642    tool-bar window-relative coordinates X/Y.  Called from
 15643    note_mouse_highlight.  */
 15644 
 15645 static void
 15646 note_tool_bar_highlight (struct frame *f, int x, int y)
 15647 {
 15648   Lisp_Object window = f->tool_bar_window;
 15649   struct window *w = XWINDOW (window);
 15650   Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f);
 15651   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 15652   int hpos, vpos;
 15653   struct glyph *glyph;
 15654   struct glyph_row *row;
 15655   int i;
 15656   Lisp_Object enabled_p;
 15657   int prop_idx;
 15658   enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
 15659   bool mouse_down_p;
 15660   int rc;
 15661 
 15662   /* Function note_mouse_highlight is called with negative X/Y
 15663      values when mouse moves outside of the frame.  */
 15664   if (x <= 0 || y <= 0)
 15665     {
 15666       clear_mouse_face (hlinfo);
 15667       return;
 15668     }
 15669 
 15670   rc = get_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
 15671   if (rc < 0)
 15672     {
 15673       /* Not on tool-bar item.  */
 15674       clear_mouse_face (hlinfo);
 15675       return;
 15676     }
 15677   else if (rc == 0)
 15678     /* On same tool-bar item as before.  */
 15679     goto set_help_echo;
 15680 
 15681   clear_mouse_face (hlinfo);
 15682 
 15683   /* Mouse is down, but on different tool-bar item?  */
 15684   mouse_down_p = (gui_mouse_grabbed (dpyinfo)
 15685                   && f == dpyinfo->last_mouse_frame);
 15686 
 15687   if (mouse_down_p && f->last_tool_bar_item != prop_idx)
 15688     return;
 15689 
 15690   draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
 15691 
 15692   /* If tool-bar item is not enabled, don't highlight it.  */
 15693   enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
 15694   if (!NILP (enabled_p) && !NILP (Vmouse_highlight))
 15695     {
 15696       /* Compute the x-position of the glyph.  In front and past the
 15697          image is a space.  We include this in the highlighted area.  */
 15698       row = MATRIX_ROW (w->current_matrix, vpos);
 15699       for (i = x = 0; i < hpos; ++i)
 15700         x += row->glyphs[TEXT_AREA][i].pixel_width;
 15701 
 15702       /* Record this as the current active region.  */
 15703       hlinfo->mouse_face_beg_col = hpos;
 15704       hlinfo->mouse_face_beg_row = vpos;
 15705       hlinfo->mouse_face_beg_x = x;
 15706       hlinfo->mouse_face_past_end = false;
 15707 
 15708       hlinfo->mouse_face_end_col = hpos + 1;
 15709       hlinfo->mouse_face_end_row = vpos;
 15710       hlinfo->mouse_face_end_x = x + glyph->pixel_width;
 15711       hlinfo->mouse_face_window = window;
 15712       hlinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
 15713 
 15714       /* Display it as active.  */
 15715       show_mouse_face (hlinfo, draw);
 15716     }
 15717 
 15718  set_help_echo:
 15719 
 15720   /* Set help_echo_string to a help string to display for this tool-bar item.
 15721      XTread_socket does the rest.  */
 15722   help_echo_object = help_echo_window = Qnil;
 15723   help_echo_pos = -1;
 15724   help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
 15725   if (NILP (help_echo_string))
 15726     help_echo_string = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
 15727 }
 15728 
 15729 #endif /* ! (HAVE_EXT_TOOL_BAR) */
 15730 
 15731 #endif /* HAVE_WINDOW_SYSTEM */
 15732 
 15733 
 15734 
 15735 /************************************************************************
 15736                          Horizontal scrolling
 15737  ************************************************************************/
 15738 
 15739 /* For all leaf windows in the window tree rooted at WINDOW, set their
 15740    hscroll value so that PT is (i) visible in the window, and (ii) so
 15741    that it is not within a certain margin at the window's left and
 15742    right border.  Value is true if any window's hscroll has been
 15743    changed.  */
 15744 
 15745 static bool
 15746 hscroll_window_tree (Lisp_Object window)
 15747 {
 15748   bool hscrolled_p = false;
 15749   bool hscroll_relative_p = FLOATP (Vhscroll_step);
 15750   int hscroll_step_abs = 0;
 15751   double hscroll_step_rel = 0;
 15752 
 15753   if (hscroll_relative_p)
 15754     {
 15755       hscroll_step_rel = XFLOAT_DATA (Vhscroll_step);
 15756       if (hscroll_step_rel < 0)
 15757         {
 15758           hscroll_relative_p = false;
 15759           hscroll_step_abs = 0;
 15760         }
 15761     }
 15762   else if (TYPE_RANGED_FIXNUMP (int, Vhscroll_step))
 15763     {
 15764       hscroll_step_abs = XFIXNUM (Vhscroll_step);
 15765       if (hscroll_step_abs < 0)
 15766         hscroll_step_abs = 0;
 15767     }
 15768   else
 15769     hscroll_step_abs = 0;
 15770 
 15771   while (WINDOWP (window))
 15772     {
 15773       struct window *w = XWINDOW (window);
 15774 
 15775       if (WINDOWP (w->contents))
 15776         hscrolled_p |= hscroll_window_tree (w->contents);
 15777       else if (w->cursor.vpos >= 0
 15778                /* Don't allow hscroll in mini-windows that display
 15779                   echo-area messages.  This is because desired_matrix
 15780                   of such windows was prepared while momentarily
 15781                   switched to an echo-area buffer, which is different
 15782                   from w->contents, and we simply cannot hscroll such
 15783                   windows safely.  */
 15784                && !(w == XWINDOW (echo_area_window)
 15785                     && !NILP (echo_area_buffer[0])))
 15786         {
 15787           int h_margin;
 15788           int text_area_width;
 15789           struct glyph_row *cursor_row;
 15790           struct glyph_row *bottom_row;
 15791 
 15792           bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->desired_matrix, w);
 15793           if (w->cursor.vpos < bottom_row - w->desired_matrix->rows)
 15794             cursor_row = MATRIX_ROW (w->desired_matrix, w->cursor.vpos);
 15795           else
 15796             cursor_row = bottom_row - 1;
 15797 
 15798           if (!cursor_row->enabled_p)
 15799             {
 15800               bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
 15801               if (w->cursor.vpos < bottom_row - w->current_matrix->rows)
 15802                 cursor_row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 15803               else
 15804                 cursor_row = bottom_row - 1;
 15805             }
 15806           bool row_r2l_p = cursor_row->reversed_p;
 15807           bool hscl = hscrolling_current_line_p (w);
 15808           int x_offset = 0;
 15809           /* When line numbers are displayed, we need to account for
 15810              the horizontal space they consume.  */
 15811           if (!NILP (Vdisplay_line_numbers))
 15812             {
 15813               struct glyph *g;
 15814               if (!row_r2l_p)
 15815                 {
 15816                   for (g = cursor_row->glyphs[TEXT_AREA];
 15817                        g < cursor_row->glyphs[TEXT_AREA]
 15818                          + cursor_row->used[TEXT_AREA];
 15819                        g++)
 15820                     {
 15821                       if (!(NILP (g->object) && g->charpos < 0))
 15822                         break;
 15823                       x_offset += g->pixel_width;
 15824                     }
 15825                 }
 15826               else
 15827                 {
 15828                   for (g = cursor_row->glyphs[TEXT_AREA]
 15829                          + cursor_row->used[TEXT_AREA];
 15830                        g > cursor_row->glyphs[TEXT_AREA];
 15831                        g--)
 15832                     {
 15833                       if (!(NILP ((g - 1)->object) && (g - 1)->charpos < 0))
 15834                         break;
 15835                       x_offset += (g - 1)->pixel_width;
 15836                     }
 15837                 }
 15838             }
 15839           if (cursor_row->truncated_on_left_p)
 15840             {
 15841               /* On TTY frames, don't count the left truncation glyph.  */
 15842               struct frame *f = XFRAME (WINDOW_FRAME (w));
 15843               x_offset -= (FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f));
 15844             }
 15845 
 15846           text_area_width = window_box_width (w, TEXT_AREA);
 15847 
 15848           /* Scroll when cursor is inside this scroll margin.  */
 15849           h_margin = (clip_to_bounds (0, hscroll_margin, 1000000)
 15850                       * WINDOW_FRAME_COLUMN_WIDTH (w));
 15851 
 15852           /* If the position of this window's point has explicitly
 15853              changed, no more suspend auto hscrolling.  */
 15854           if (w->suspend_auto_hscroll
 15855               && NILP (Fequal (Fwindow_point (window),
 15856                                Fwindow_old_point (window))))
 15857             {
 15858               w->suspend_auto_hscroll = false;
 15859               /* When hscrolling just the current line, and the rest
 15860                  of lines were temporarily hscrolled, but no longer
 15861                  are, force thorough redisplay of this window, to show
 15862                  the effect of disabling hscroll suspension immediately.  */
 15863               if (w->min_hscroll == 0 && w->hscroll > 0
 15864                   && EQ (Fbuffer_local_value (Qauto_hscroll_mode, w->contents),
 15865                          Qcurrent_line))
 15866                 SET_FRAME_GARBAGED (XFRAME (w->frame));
 15867             }
 15868 
 15869           /* Remember window point.  */
 15870           Fset_marker (w->old_pointm,
 15871                        ((w == XWINDOW (selected_window))
 15872                         ? make_fixnum (BUF_PT (XBUFFER (w->contents)))
 15873                         : Fmarker_position (w->pointm)),
 15874                        w->contents);
 15875 
 15876           if (!NILP (Fbuffer_local_value (Qauto_hscroll_mode, w->contents))
 15877               && !w->suspend_auto_hscroll
 15878               /* In some pathological cases, like restoring a window
 15879                  configuration into a frame that is much smaller than
 15880                  the one from which the configuration was saved, we
 15881                  get glyph rows whose start and end have zero buffer
 15882                  positions, which we cannot handle below.  Just skip
 15883                  such windows.  */
 15884               && (CHARPOS (cursor_row->start.pos)
 15885                   >= BUF_BEG (XBUFFER (w->contents)))
 15886               /* For left-to-right rows, hscroll when cursor is either
 15887                  (i) inside the right hscroll margin, or (ii) if it is
 15888                  inside the left margin and the window is already
 15889                  hscrolled.  */
 15890               && ((!row_r2l_p
 15891                    && ((w->hscroll && w->cursor.x <= h_margin + x_offset)
 15892                        || (cursor_row->enabled_p
 15893                            && cursor_row->truncated_on_right_p
 15894                            && (w->cursor.x >= text_area_width - h_margin))))
 15895                   /* For right-to-left rows, the logic is similar,
 15896                      except that rules for scrolling to left and right
 15897                      are reversed.  E.g., if cursor.x <= h_margin, we
 15898                      need to hscroll "to the right" unconditionally,
 15899                      and that will scroll the screen to the left so as
 15900                      to reveal the next portion of the row.  */
 15901                   || (row_r2l_p
 15902                       && ((cursor_row->enabled_p
 15903                            /* FIXME: It is confusing to set the
 15904                               truncated_on_right_p flag when R2L rows
 15905                               are actually truncated on the left.  */
 15906                            && cursor_row->truncated_on_right_p
 15907                            && w->cursor.x <= h_margin)
 15908                           || (w->hscroll
 15909                               && (w->cursor.x >= (text_area_width - h_margin
 15910                                                   - x_offset)))))
 15911                   /* This last condition is needed when moving
 15912                      vertically from an hscrolled line to a short line
 15913                      that doesn't need to be hscrolled.  If we omit
 15914                      this condition, the line from which we move will
 15915                      remain hscrolled.  */
 15916                   || (hscl
 15917                       && w->hscroll != w->min_hscroll
 15918                       && !cursor_row->truncated_on_left_p)))
 15919             {
 15920               struct it it;
 15921               ptrdiff_t hscroll;
 15922               struct buffer *saved_current_buffer;
 15923               ptrdiff_t pt;
 15924               int wanted_x;
 15925 
 15926               /* Find point in a display of infinite width.  */
 15927               saved_current_buffer = current_buffer;
 15928               current_buffer = XBUFFER (w->contents);
 15929 
 15930               if (w == XWINDOW (selected_window))
 15931                 pt = PT;
 15932               else
 15933                 pt = clip_to_bounds (BEGV, marker_position (w->pointm), ZV);
 15934 
 15935               /* Move iterator to pt starting at cursor_row->start in
 15936                  a line with infinite width.  */
 15937               init_to_row_start (&it, w, cursor_row);
 15938               if (hscl)
 15939                 it.first_visible_x = window_hscroll_limited (w, it.f)
 15940                                      * FRAME_COLUMN_WIDTH (it.f);
 15941               it.last_visible_x = DISP_INFINITY;
 15942 
 15943               ptrdiff_t nchars = pt - IT_CHARPOS (it);
 15944               if (current_buffer->long_line_optimizations_p
 15945                   && nchars > large_hscroll_threshold)
 15946                 {
 15947                   /* Special optimization for very long and truncated
 15948                      lines which need to be hscrolled far to the left:
 15949                      jump directly to the (approximate) first position
 15950                      that is visible, instead of slowly walking there.  */
 15951                   fast_move_it_horizontally (&it, nchars);
 15952                   it.current_x += nchars * FRAME_COLUMN_WIDTH (it.f);
 15953                 }
 15954               else
 15955                 move_it_in_display_line_to (&it, pt, -1, MOVE_TO_POS);
 15956               /* If the line ends in an overlay string with a newline,
 15957                  we might infloop, because displaying the window will
 15958                  want to put the cursor after the overlay, i.e. at X
 15959                  coordinate of zero on the next screen line.  So we
 15960                  use the buffer position prior to the overlay string
 15961                  instead.  */
 15962               if (it.method == GET_FROM_STRING && pt > 1)
 15963                 {
 15964                   init_to_row_start (&it, w, cursor_row);
 15965                   if (hscl)
 15966                     it.first_visible_x = (window_hscroll_limited (w, it.f)
 15967                                           * FRAME_COLUMN_WIDTH (it.f));
 15968                   if (current_buffer->long_line_optimizations_p
 15969                       && nchars > large_hscroll_threshold)
 15970                     {
 15971                       fast_move_it_horizontally (&it, nchars - 1);
 15972                       it.current_x += (nchars - 1) * FRAME_COLUMN_WIDTH (it.f);
 15973                     }
 15974                   else
 15975                     move_it_in_display_line_to (&it, pt - 1, -1, MOVE_TO_POS);
 15976                 }
 15977               current_buffer = saved_current_buffer;
 15978 
 15979               /* Position cursor in window.  */
 15980               if (!hscroll_relative_p && hscroll_step_abs == 0)
 15981                 hscroll = max (0, (it.current_x
 15982                                    - (ITERATOR_AT_END_OF_LINE_P (&it)
 15983                                       ? (text_area_width - 4 * FRAME_COLUMN_WIDTH (it.f))
 15984                                       : (text_area_width / 2))))
 15985                           / FRAME_COLUMN_WIDTH (it.f);
 15986               else if ((!row_r2l_p
 15987                         && w->cursor.x >= text_area_width - h_margin)
 15988                        || (row_r2l_p && w->cursor.x <= h_margin))
 15989                 {
 15990                   if (hscroll_relative_p)
 15991                     wanted_x = text_area_width * (1 - hscroll_step_rel)
 15992                                - h_margin;
 15993                   else
 15994                     wanted_x = text_area_width
 15995                                - hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
 15996                                - h_margin;
 15997                   hscroll
 15998                     = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
 15999                 }
 16000               else
 16001                 {
 16002                   if (hscroll_relative_p)
 16003                     wanted_x =
 16004                       text_area_width * hscroll_step_rel + h_margin + x_offset;
 16005                   else
 16006                     wanted_x =
 16007                       hscroll_step_abs * FRAME_COLUMN_WIDTH (it.f)
 16008                       + h_margin + x_offset;
 16009                   hscroll
 16010                     = max (0, it.current_x - wanted_x) / FRAME_COLUMN_WIDTH (it.f);
 16011                 }
 16012               hscroll = max (hscroll, w->min_hscroll);
 16013 
 16014               /* Don't prevent redisplay optimizations if hscroll
 16015                  hasn't changed, as it will unnecessarily slow down
 16016                  redisplay.  */
 16017               if (w->hscroll != hscroll
 16018                   /* When hscrolling only the current line, we need to
 16019                      report hscroll even if its value is equal to the
 16020                      previous one, because the new line might need a
 16021                      different value.  */
 16022                   || (hscl && w->last_cursor_vpos != w->cursor.vpos))
 16023                 {
 16024                   struct buffer *b = XBUFFER (w->contents);
 16025                   b->prevent_redisplay_optimizations_p = true;
 16026                   w->hscroll = hscroll;
 16027                   hscrolled_p = true;
 16028                 }
 16029             }
 16030         }
 16031 
 16032       window = w->next;
 16033     }
 16034 
 16035   /* Value is true if hscroll of any leaf window has been changed.  */
 16036   return hscrolled_p;
 16037 }
 16038 
 16039 
 16040 /* Set hscroll so that cursor is visible and not inside horizontal
 16041    scroll margins for all windows in the tree rooted at WINDOW.  See
 16042    also hscroll_window_tree above.  Value is true if any window's
 16043    hscroll has been changed.  If it has, desired matrices on the frame
 16044    of WINDOW are cleared.  */
 16045 
 16046 static bool
 16047 hscroll_windows (Lisp_Object window)
 16048 {
 16049   bool hscrolled_p = hscroll_window_tree (window);
 16050   if (hscrolled_p)
 16051     clear_desired_matrices (XFRAME (WINDOW_FRAME (XWINDOW (window))));
 16052   return hscrolled_p;
 16053 }
 16054 
 16055 
 16056 
 16057 /************************************************************************
 16058                                 Redisplay
 16059  ************************************************************************/
 16060 
 16061 /* Variables holding some state of redisplay if GLYPH_DEBUG is defined.
 16062    This is sometimes handy to have in a debugger session.  */
 16063 
 16064 #ifdef GLYPH_DEBUG
 16065 
 16066 /* First and last unchanged row for try_window_id.  */
 16067 
 16068 static int debug_first_unchanged_at_end_vpos;
 16069 static int debug_last_unchanged_at_beg_vpos;
 16070 
 16071 /* Delta vpos and y.  */
 16072 
 16073 static int debug_dvpos, debug_dy;
 16074 
 16075 /* Delta in characters and bytes for try_window_id.  */
 16076 
 16077 static ptrdiff_t debug_delta, debug_delta_bytes;
 16078 
 16079 /* Values of window_end_pos and window_end_vpos at the end of
 16080    try_window_id.  */
 16081 
 16082 static ptrdiff_t debug_end_vpos;
 16083 
 16084 /* Append a string to W->desired_matrix->method.  FMT is a printf
 16085    format string.  If trace_redisplay_p is true also printf the
 16086    resulting string to stderr.  */
 16087 
 16088 static void debug_method_add (struct window *, char const *, ...)
 16089   ATTRIBUTE_FORMAT_PRINTF (2, 3);
 16090 
 16091 static void
 16092 debug_method_add (struct window *w, char const *fmt, ...)
 16093 {
 16094   void *ptr = w;
 16095   char *method = w->desired_matrix->method;
 16096   int len = strlen (method);
 16097   int size = sizeof w->desired_matrix->method;
 16098   int remaining = size - len - 1;
 16099   va_list ap;
 16100 
 16101   if (len && remaining)
 16102     {
 16103       method[len] = '|';
 16104       --remaining, ++len;
 16105     }
 16106 
 16107   va_start (ap, fmt);
 16108   vsnprintf (method + len, remaining + 1, fmt, ap);
 16109   va_end (ap);
 16110 
 16111   if (trace_redisplay_p)
 16112     fprintf (stderr, "%p (%s): %s\n",
 16113              ptr,
 16114              ((BUFFERP (w->contents)
 16115                && STRINGP (BVAR (XBUFFER (w->contents), name)))
 16116               ? SSDATA (BVAR (XBUFFER (w->contents), name))
 16117               : "no buffer"),
 16118              method + len);
 16119 }
 16120 
 16121 #endif /* GLYPH_DEBUG */
 16122 
 16123 
 16124 /* Value is true if all changes in window W, which displays
 16125    current_buffer, are in the text between START and END.  START is a
 16126    buffer position, END is given as a distance from Z.  Used in
 16127    redisplay_internal for display optimization.  */
 16128 
 16129 static bool
 16130 text_outside_line_unchanged_p (struct window *w,
 16131                                ptrdiff_t start, ptrdiff_t end)
 16132 {
 16133   bool unchanged_p = true;
 16134 
 16135   /* If text or overlays have changed, see where.  */
 16136   if (window_outdated (w))
 16137     {
 16138       /* Gap in the line?  */
 16139       if (GPT < start || Z - GPT < end)
 16140         unchanged_p = false;
 16141 
 16142       /* Changes start in front of the line, or end after it?  */
 16143       if (unchanged_p
 16144           && (BEG_UNCHANGED < start - 1
 16145               || END_UNCHANGED < end))
 16146         unchanged_p = false;
 16147 
 16148       /* If selective display, can't optimize if changes start at the
 16149          beginning of the line.  */
 16150       if (unchanged_p
 16151           && FIXNUMP (BVAR (current_buffer, selective_display))
 16152           && XFIXNUM (BVAR (current_buffer, selective_display)) > 0
 16153           && (BEG_UNCHANGED < start || GPT <= start))
 16154         unchanged_p = false;
 16155 
 16156       /* If there are overlays at the start or end of the line, these
 16157          may have overlay strings with newlines in them.  A change at
 16158          START, for instance, may actually concern the display of such
 16159          overlay strings as well, and they are displayed on different
 16160          lines.  So, quickly rule out this case.  (For the future, it
 16161          might be desirable to implement something more telling than
 16162          just BEG/END_UNCHANGED.)  */
 16163       if (unchanged_p)
 16164         {
 16165           if (BEG + BEG_UNCHANGED == start
 16166               && overlay_touches_p (start))
 16167             unchanged_p = false;
 16168           if (END_UNCHANGED == end
 16169               && overlay_touches_p (Z - end))
 16170             unchanged_p = false;
 16171         }
 16172 
 16173       /* Under bidi reordering, adding or deleting a character in the
 16174          beginning of a paragraph, before the first strong directional
 16175          character, can change the base direction of the paragraph (unless
 16176          the buffer specifies a fixed paragraph direction), which will
 16177          require redisplaying the whole paragraph.  It might be worthwhile
 16178          to find the paragraph limits and widen the range of redisplayed
 16179          lines to that, but for now just give up this optimization.  */
 16180       if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
 16181           && NILP (BVAR (XBUFFER (w->contents), bidi_paragraph_direction)))
 16182         unchanged_p = false;
 16183     }
 16184 
 16185   return unchanged_p;
 16186 }
 16187 
 16188 
 16189 /* Do a frame update, taking possible shortcuts into account.  This is
 16190    the main external entry point for redisplay.
 16191 
 16192    If the last redisplay displayed an echo area message and that message
 16193    is no longer requested, we clear the echo area or bring back the
 16194    mini-buffer if that is in use.  */
 16195 
 16196 void
 16197 redisplay (void)
 16198 {
 16199   redisplay_internal ();
 16200 }
 16201 
 16202 
 16203 static Lisp_Object
 16204 overlay_arrow_string_or_property (Lisp_Object var)
 16205 {
 16206   Lisp_Object val;
 16207 
 16208   if (val = Fget (var, Qoverlay_arrow_string), STRINGP (val))
 16209     return val;
 16210 
 16211   return Voverlay_arrow_string;
 16212 }
 16213 
 16214 /* Return true if there are any overlay-arrows in current_buffer.  */
 16215 static bool
 16216 overlay_arrow_in_current_buffer_p (void)
 16217 {
 16218   Lisp_Object vlist;
 16219 
 16220   for (vlist = Voverlay_arrow_variable_list;
 16221        CONSP (vlist);
 16222        vlist = XCDR (vlist))
 16223     {
 16224       Lisp_Object var = XCAR (vlist);
 16225       Lisp_Object val;
 16226 
 16227       if (!SYMBOLP (var))
 16228         continue;
 16229       val = find_symbol_value (var);
 16230       if (MARKERP (val)
 16231           && current_buffer == XMARKER (val)->buffer)
 16232         return true;
 16233     }
 16234   return false;
 16235 }
 16236 
 16237 
 16238 /* Return true if any overlay_arrows have moved or overlay-arrow-string
 16239    has changed.
 16240    If SET_REDISPLAY is true, additionally, set the `redisplay' bit in those
 16241    buffers that are affected.  */
 16242 
 16243 static bool
 16244 overlay_arrows_changed_p (bool set_redisplay)
 16245 {
 16246   Lisp_Object vlist;
 16247   bool changed = false;
 16248 
 16249   for (vlist = Voverlay_arrow_variable_list;
 16250        CONSP (vlist);
 16251        vlist = XCDR (vlist))
 16252     {
 16253       Lisp_Object var = XCAR (vlist);
 16254       Lisp_Object val, pstr;
 16255 
 16256       if (!SYMBOLP (var))
 16257         continue;
 16258       val = find_symbol_value (var);
 16259       if (!MARKERP (val))
 16260         continue;
 16261       if (! EQ (Fmarker_position (val),
 16262                 /* FIXME: Don't we have a problem, using such a global
 16263                  * "last-position" if the variable is buffer-local?  */
 16264                 Fget (var, Qlast_arrow_position))
 16265           || ! (pstr = overlay_arrow_string_or_property (var),
 16266                 EQ (pstr, Fget (var, Qlast_arrow_string))))
 16267         {
 16268           struct buffer *buf = XMARKER (val)->buffer;
 16269 
 16270           if (set_redisplay)
 16271             {
 16272               if (buf)
 16273                 bset_redisplay (buf);
 16274               changed = true;
 16275             }
 16276           else
 16277             return true;
 16278         }
 16279     }
 16280   return changed;
 16281 }
 16282 
 16283 /* Mark overlay arrows to be updated on next redisplay.  */
 16284 
 16285 static void
 16286 update_overlay_arrows (int up_to_date)
 16287 {
 16288   Lisp_Object vlist;
 16289 
 16290   for (vlist = Voverlay_arrow_variable_list;
 16291        CONSP (vlist);
 16292        vlist = XCDR (vlist))
 16293     {
 16294       Lisp_Object var = XCAR (vlist);
 16295 
 16296       if (!SYMBOLP (var))
 16297         continue;
 16298 
 16299       if (up_to_date > 0)
 16300         {
 16301           Lisp_Object val = find_symbol_value (var);
 16302           if (!MARKERP (val))
 16303             continue;
 16304           Fput (var, Qlast_arrow_position, Fmarker_position (val));
 16305           Fput (var, Qlast_arrow_string,
 16306                 overlay_arrow_string_or_property (var));
 16307         }
 16308       else if (up_to_date < 0
 16309                || !NILP (Fget (var, Qlast_arrow_position)))
 16310         {
 16311           Fput (var, Qlast_arrow_position, Qt);
 16312           Fput (var, Qlast_arrow_string, Qt);
 16313         }
 16314     }
 16315 }
 16316 
 16317 
 16318 /* Return overlay arrow string to display at row.
 16319    Return integer (bitmap number) for arrow bitmap in left fringe.
 16320    Return nil if no overlay arrow.  */
 16321 
 16322 static Lisp_Object
 16323 overlay_arrow_at_row (struct it *it, struct glyph_row *row)
 16324 {
 16325   Lisp_Object vlist;
 16326 
 16327   for (vlist = Voverlay_arrow_variable_list;
 16328        CONSP (vlist);
 16329        vlist = XCDR (vlist))
 16330     {
 16331       Lisp_Object var = XCAR (vlist);
 16332       Lisp_Object val;
 16333 
 16334       if (!SYMBOLP (var))
 16335         continue;
 16336 
 16337       val = find_symbol_value (var);
 16338 
 16339       if (MARKERP (val)
 16340           && current_buffer == XMARKER (val)->buffer
 16341           && (MATRIX_ROW_START_CHARPOS (row) == marker_position (val)))
 16342         {
 16343           if (FRAME_WINDOW_P (it->f)
 16344               /* FIXME: if ROW->reversed_p is set, this should test
 16345                  the right fringe, not the left one.  */
 16346               && WINDOW_LEFT_FRINGE_WIDTH (it->w) > 0)
 16347             {
 16348 #ifdef HAVE_WINDOW_SYSTEM
 16349               if (val = Fget (var, Qoverlay_arrow_bitmap), SYMBOLP (val))
 16350                 {
 16351                   int fringe_bitmap = lookup_fringe_bitmap (val);
 16352                   if (fringe_bitmap != 0)
 16353                     return make_fixnum (fringe_bitmap);
 16354                 }
 16355 #endif
 16356               return make_fixnum (-1); /* Use default arrow bitmap.  */
 16357             }
 16358           return overlay_arrow_string_or_property (var);
 16359         }
 16360     }
 16361 
 16362   return Qnil;
 16363 }
 16364 
 16365 /* Return true if point moved out of or into a composition.  Otherwise
 16366    return false.  PREV_BUF and PREV_PT are the last point buffer and
 16367    position.  BUF and PT are the current point buffer and position.  */
 16368 
 16369 static bool
 16370 check_point_in_composition (struct buffer *prev_buf, ptrdiff_t prev_pt,
 16371                             struct buffer *buf, ptrdiff_t pt)
 16372 {
 16373   ptrdiff_t start, end;
 16374   Lisp_Object prop;
 16375   Lisp_Object buffer;
 16376 
 16377   XSETBUFFER (buffer, buf);
 16378   /* Check a composition at the last point if point moved within the
 16379      same buffer.  */
 16380   if (prev_buf == buf)
 16381     {
 16382       if (prev_pt == pt)
 16383         /* Point didn't move.  */
 16384         return false;
 16385 
 16386       if (prev_pt > BUF_BEGV (buf) && prev_pt < BUF_ZV (buf)
 16387           && find_composition (prev_pt, -1, &start, &end, &prop, buffer)
 16388           && composition_valid_p (start, end, prop)
 16389           && start < prev_pt && end > prev_pt)
 16390         /* The last point was within the composition.  Return true iff
 16391             point moved out of the composition.  */
 16392         return (pt <= start || pt >= end);
 16393     }
 16394 
 16395   /* Check a composition at the current point.  */
 16396   return (pt > BUF_BEGV (buf) && pt < BUF_ZV (buf)
 16397           && find_composition (pt, -1, &start, &end, &prop, buffer)
 16398           && composition_valid_p (start, end, prop)
 16399           && start < pt && end > pt);
 16400 }
 16401 
 16402 /* Reconsider the clip changes of buffer which is displayed in W.  */
 16403 
 16404 static void
 16405 reconsider_clip_changes (struct window *w)
 16406 {
 16407   struct buffer *b = XBUFFER (w->contents);
 16408 
 16409   if (b->clip_changed
 16410       && w->window_end_valid
 16411       && w->current_matrix->buffer == b
 16412       && w->current_matrix->zv == BUF_ZV (b)
 16413       && w->current_matrix->begv == BUF_BEGV (b))
 16414     b->clip_changed = false;
 16415 
 16416   /* If display wasn't paused, and W is not a tool bar window, see if
 16417      point has been moved into or out of a composition.  In that case,
 16418      set b->clip_changed to force updating the screen.  If
 16419      b->clip_changed has already been set, skip this check.  */
 16420   if (!b->clip_changed && w->window_end_valid)
 16421     {
 16422       ptrdiff_t pt = (w == XWINDOW (selected_window)
 16423                       ? PT : marker_position (w->pointm));
 16424 
 16425       if ((w->current_matrix->buffer != b || pt != w->last_point)
 16426           && check_point_in_composition (w->current_matrix->buffer,
 16427                                          w->last_point, b, pt))
 16428         b->clip_changed = true;
 16429     }
 16430 }
 16431 
 16432 static void
 16433 propagate_buffer_redisplay (void)
 16434 { /* Resetting b->text->redisplay is problematic!
 16435      We can't just reset it in the case that some window that displays
 16436      it has not been redisplayed; and such a window can stay
 16437      unredisplayed for a long time if it's currently invisible.
 16438      But we do want to reset it at the end of redisplay otherwise
 16439      its displayed windows will keep being redisplayed over and over
 16440      again.
 16441      So we copy all b->text->redisplay flags up to their windows here,
 16442      such that mark_window_display_accurate can safely reset
 16443      b->text->redisplay.  */
 16444   Lisp_Object ws = window_list ();
 16445   for (; CONSP (ws); ws = XCDR (ws))
 16446     {
 16447       struct window *thisw = XWINDOW (XCAR (ws));
 16448       struct buffer *thisb = XBUFFER (thisw->contents);
 16449       if (thisb->text->redisplay)
 16450         thisw->redisplay = true;
 16451     }
 16452 }
 16453 
 16454 #define STOP_POLLING                                    \
 16455 do { if (! polling_stopped_here) stop_polling ();       \
 16456        polling_stopped_here = true; } while (false)
 16457 
 16458 #define RESUME_POLLING                                  \
 16459 do { if (polling_stopped_here) start_polling ();        \
 16460        polling_stopped_here = false; } while (false)
 16461 
 16462 /* Perhaps in the future avoid recentering windows if it
 16463    is not necessary; currently that causes some problems.  */
 16464 
 16465 static void
 16466 redisplay_internal (void)
 16467 {
 16468   struct window *w = XWINDOW (selected_window);
 16469   struct window *sw;
 16470   struct frame *fr;
 16471   bool pending;
 16472   bool must_finish = false, match_p;
 16473   struct text_pos tlbufpos, tlendpos;
 16474   int number_of_visible_frames;
 16475   struct frame *sf;
 16476   bool polling_stopped_here = false;
 16477   Lisp_Object tail, frame;
 16478 
 16479   /* Set a limit to the number of retries we perform due to horizontal
 16480      scrolling, this avoids getting stuck in an uninterruptible
 16481      infinite loop (Bug #24633).  */
 16482   enum { MAX_HSCROLL_RETRIES = 16 };
 16483   int hscroll_retries = 0;
 16484 
 16485   /* Limit the number of retries for when frame(s) become garbaged as
 16486      result of redisplaying them.  Some packages set various redisplay
 16487      hooks, such as window-scroll-functions, to run Lisp that always
 16488      calls APIs which cause the frame's garbaged flag to become set,
 16489      so we loop indefinitely.  */
 16490   enum {MAX_GARBAGED_FRAME_RETRIES = 2 };
 16491   int garbaged_frame_retries = 0;
 16492 
 16493   /* True means redisplay has to consider all windows on all
 16494      frames.  False, only selected_window is considered.  */
 16495   bool consider_all_windows_p;
 16496 
 16497   /* True means redisplay has to redisplay the miniwindow.  */
 16498   bool update_miniwindow_p = false;
 16499 
 16500   redisplay_trace ("redisplay_internal %d\n", redisplaying_p);
 16501 
 16502   /* No redisplay if running in batch mode or frame is not yet fully
 16503      initialized, or redisplay is explicitly turned off by setting
 16504      Vinhibit_redisplay.  */
 16505   if ((FRAME_INITIAL_P (SELECTED_FRAME ())
 16506        && redisplay_skip_initial_frame)
 16507       || !NILP (Vinhibit_redisplay))
 16508     return;
 16509 
 16510   /* Don't examine these until after testing Vinhibit_redisplay.
 16511      When Emacs is shutting down, perhaps because its connection to
 16512      X has dropped, we should not look at them at all.  */
 16513   fr = XFRAME (w->frame);
 16514   sf = SELECTED_FRAME ();
 16515 
 16516   if (!fr->glyphs_initialized_p)
 16517     return;
 16518 
 16519 #if defined (USE_X_TOOLKIT) || defined (USE_GTK) || defined (HAVE_NS)
 16520   if (popup_activated ())
 16521     return;
 16522 #endif
 16523 
 16524 #if defined (HAVE_HAIKU)
 16525   if (popup_activated_p)
 16526     return;
 16527 #endif
 16528 
 16529   /* I don't think this happens but let's be paranoid.  */
 16530   if (redisplaying_p)
 16531     return;
 16532 
 16533   /* Record a function that clears redisplaying_p
 16534      when we leave this function.  */
 16535   specpdl_ref count = SPECPDL_INDEX ();
 16536   record_unwind_protect_void (unwind_redisplay);
 16537   redisplaying_p = true;
 16538   block_buffer_flips ();
 16539   specbind (Qinhibit_free_realized_faces, Qnil);
 16540 
 16541   /* Record this function, so it appears on the profiler's backtraces.  */
 16542   record_in_backtrace (Qredisplay_internal_xC_functionx, 0, 0);
 16543 
 16544   FOR_EACH_FRAME (tail, frame)
 16545     XFRAME (frame)->already_hscrolled_p = false;
 16546 
 16547   reset_outermost_restrictions ();
 16548 
 16549  retry:
 16550   /* Remember the currently selected window.  */
 16551   sw = w;
 16552 
 16553   pending = false;
 16554   forget_escape_and_glyphless_faces ();
 16555 
 16556   inhibit_free_realized_faces = false;
 16557 
 16558   /* If face_change, init_iterator will free all realized faces, which
 16559      includes the faces referenced from current matrices.  So, we
 16560      can't reuse current matrices in this case.  */
 16561   if (face_change)
 16562     windows_or_buffers_changed = 47;
 16563 
 16564   if ((FRAME_TERMCAP_P (sf) || FRAME_MSDOS_P (sf))
 16565       && FRAME_TTY (sf)->previous_frame != sf)
 16566     {
 16567       /* Since frames on a single ASCII terminal share the same
 16568          display area, displaying a different frame means redisplay
 16569          the whole thing.  */
 16570       SET_FRAME_GARBAGED (sf);
 16571 #ifndef DOS_NT
 16572       set_tty_color_mode (FRAME_TTY (sf), sf);
 16573 #endif
 16574       FRAME_TTY (sf)->previous_frame = sf;
 16575     }
 16576 
 16577   /* Set the visible flags for all frames.  Do this before checking for
 16578      resized or garbaged frames; they want to know if their frames are
 16579      visible.  See the comment in frame.h for FRAME_SAMPLE_VISIBILITY.  */
 16580   number_of_visible_frames = 0;
 16581 
 16582   FOR_EACH_FRAME (tail, frame)
 16583     {
 16584       struct frame *f = XFRAME (frame);
 16585 
 16586       if (FRAME_REDISPLAY_P (f))
 16587         {
 16588           ++number_of_visible_frames;
 16589           /* Adjust matrices for visible frames only.  */
 16590           if (f->fonts_changed)
 16591             {
 16592               adjust_frame_glyphs (f);
 16593               /* Disable all redisplay optimizations for this frame.
 16594                  This is because adjust_frame_glyphs resets the
 16595                  enabled_p flag for all glyph rows of all windows, so
 16596                  many optimizations will fail anyway, and some might
 16597                  fail to test that flag and do bogus things as
 16598                  result.  */
 16599               SET_FRAME_GARBAGED (f);
 16600               f->fonts_changed = false;
 16601             }
 16602           /* If cursor type has been changed on the frame
 16603              other than selected, consider all frames.  */
 16604           if (f != sf && f->cursor_type_changed)
 16605             fset_redisplay (f);
 16606         }
 16607       clear_desired_matrices (f);
 16608     }
 16609 
 16610   /* Notice any pending interrupt request to change frame size.  */
 16611   do_pending_window_change (true);
 16612 
 16613   /* Clear frames marked as garbaged.  */
 16614   clear_garbaged_frames ();
 16615 
 16616   /* Build menubar and tool-bar items.  */
 16617   if (NILP (Vmemory_full))
 16618     prepare_menu_bars ();
 16619 
 16620   /* do_pending_window_change could change the selected_window due to
 16621      frame resizing which makes the selected window too small.
 16622      prepare_menu_bars may call lisp hooks and hence also change the
 16623      selected_window.  */
 16624   if (WINDOWP (selected_window) && (w = XWINDOW (selected_window)) != sw)
 16625     sw = w;
 16626 
 16627   reconsider_clip_changes (w);
 16628 
 16629   /* In most cases selected window displays current buffer.  */
 16630   match_p = XBUFFER (w->contents) == current_buffer;
 16631   if (match_p)
 16632     {
 16633       /* Detect case that we need to write or remove a star in the mode line.  */
 16634       if ((SAVE_MODIFF < MODIFF) != w->last_had_star)
 16635         w->update_mode_line = true;
 16636 
 16637       if (mode_line_update_needed (w))
 16638         w->update_mode_line = true;
 16639 
 16640       /* If reconsider_clip_changes above decided that the narrowing
 16641          in the current buffer changed, make sure all other windows
 16642          showing that buffer will be redisplayed.  */
 16643       if (current_buffer->clip_changed)
 16644         bset_update_mode_line (current_buffer);
 16645     }
 16646 
 16647   /* Normally the message* functions will have already displayed and
 16648      updated the echo area, but the frame may have been trashed, or
 16649      the update may have been preempted, so display the echo area
 16650      again here.  Checking message_cleared_p captures the case that
 16651      the echo area should be cleared.  */
 16652   if ((!NILP (echo_area_buffer[0]) && !display_last_displayed_message_p)
 16653       || (!NILP (echo_area_buffer[1]) && display_last_displayed_message_p)
 16654       || (message_cleared_p
 16655           && minibuf_level == 0
 16656           /* If the mini-window is currently selected, this means the
 16657              echo-area doesn't show through.  */
 16658           && !MINI_WINDOW_P (XWINDOW (selected_window))))
 16659     {
 16660       echo_area_display (false);
 16661 
 16662       if (message_cleared_p)
 16663         update_miniwindow_p = true;
 16664 
 16665       must_finish = true;
 16666 
 16667       /* If we don't display the current message, don't clear the
 16668          message_cleared_p flag, because, if we did, we wouldn't clear
 16669          the echo area in the next redisplay which doesn't preserve
 16670          the echo area.  */
 16671       if (!display_last_displayed_message_p)
 16672         message_cleared_p = false;
 16673     }
 16674   else if (EQ (selected_window, minibuf_window)
 16675            && (current_buffer->clip_changed || window_outdated (w))
 16676            && resize_mini_window (w, false))
 16677     {
 16678       /* Resized active mini-window to fit the size of what it is
 16679          showing if its contents might have changed.  */
 16680       must_finish = true;
 16681 
 16682       /* If window configuration was changed, frames may have been
 16683          marked garbaged.  Clear them or we will experience
 16684          surprises wrt scrolling.  */
 16685       clear_garbaged_frames ();
 16686     }
 16687 
 16688   if (!NILP (Vrun_hooks))
 16689     run_window_change_functions ();
 16690 
 16691   if (windows_or_buffers_changed && !update_mode_lines)
 16692     /* Code that sets windows_or_buffers_changed doesn't distinguish whether
 16693        only the windows's contents needs to be refreshed, or whether the
 16694        mode-lines also need a refresh.  */
 16695     update_mode_lines = (windows_or_buffers_changed == REDISPLAY_SOME
 16696                          ? REDISPLAY_SOME : 32);
 16697 
 16698   /* If specs for an arrow have changed, do thorough redisplay
 16699      to ensure we remove any arrow that should no longer exist.  */
 16700   /* Apparently, this is the only case where we update other windows,
 16701      without updating other mode-lines.  */
 16702   overlay_arrows_changed_p (true);
 16703 
 16704   consider_all_windows_p = (update_mode_lines
 16705                             || windows_or_buffers_changed);
 16706 
 16707 #define AINC(a,i)                                                       \
 16708   {                                                                     \
 16709     Lisp_Object entry = Fgethash (make_fixnum (i), a, make_fixnum (0)); \
 16710     if (FIXNUMP (entry))                                                \
 16711       Fputhash (make_fixnum (i), make_fixnum (1 + XFIXNUM (entry)), a); \
 16712   }
 16713 
 16714   AINC (Vredisplay__all_windows_cause, windows_or_buffers_changed);
 16715   AINC (Vredisplay__mode_lines_cause, update_mode_lines);
 16716 
 16717   /* Optimize the case that only the line containing the cursor in the
 16718      selected window has changed.  Variables starting with this_ are
 16719      set in display_line and record information about the line
 16720      containing the cursor.  */
 16721   tlbufpos = this_line_start_pos;
 16722   tlendpos = this_line_end_pos;
 16723   if (!consider_all_windows_p
 16724       && CHARPOS (tlbufpos) > 0
 16725       && !w->update_mode_line
 16726       && !current_buffer->clip_changed
 16727       && !current_buffer->prevent_redisplay_optimizations_p
 16728       && FRAME_REDISPLAY_P (XFRAME (w->frame))
 16729       && !FRAME_OBSCURED_P (XFRAME (w->frame))
 16730       && !XFRAME (w->frame)->cursor_type_changed
 16731       && !XFRAME (w->frame)->face_change
 16732       /* Make sure recorded data applies to current buffer, etc.  */
 16733       && this_line_buffer == current_buffer
 16734       && match_p
 16735       && !w->force_start
 16736       && !w->optional_new_start
 16737       /* Point must be on the line that we have info recorded about.  */
 16738       && PT >= CHARPOS (tlbufpos)
 16739       && PT <= Z - CHARPOS (tlendpos)
 16740       /* FIXME: The following condition is only needed when
 16741          significant parts of the buffer are hidden (e.g., under
 16742          hs-minor-mode), but there doesn't seem to be a simple way of
 16743          detecting that, so we always disable the one-line redisplay
 16744          optimizations whenever display-line-numbers-mode is turned on
 16745          in the buffer.  */
 16746       && (NILP (Vdisplay_line_numbers)
 16747           || EQ (Vdisplay_line_numbers, Qvisual))
 16748       /* All text outside that line, including its final newline,
 16749          must be unchanged.  */
 16750       && text_outside_line_unchanged_p (w, CHARPOS (tlbufpos),
 16751                                         CHARPOS (tlendpos)))
 16752     {
 16753       if (CHARPOS (tlbufpos) > BEGV
 16754           && FETCH_BYTE (BYTEPOS (tlbufpos) - 1) != '\n'
 16755           && (CHARPOS (tlbufpos) == ZV
 16756               || FETCH_BYTE (BYTEPOS (tlbufpos)) == '\n'))
 16757         /* Former continuation line has disappeared by becoming empty.  */
 16758         goto cancel;
 16759       else if (window_outdated (w) || MINI_WINDOW_P (w))
 16760         {
 16761           /* We have to handle the case of continuation around a
 16762              wide-column character (see the comment in indent.c around
 16763              line 1340).
 16764 
 16765              For instance, in the following case:
 16766 
 16767              --------  Insert  --------
 16768              K_A_N_\\   `a'    K_A_N_a\         `X_' are wide-column chars.
 16769              J_I_       ==>    J_I_             `^^' are cursors.
 16770              ^^                ^^
 16771              --------          --------
 16772 
 16773              As we have to redraw the line above, we cannot use this
 16774              optimization.  */
 16775 
 16776           struct it it;
 16777           int line_height_before = this_line_pixel_height;
 16778 
 16779           /* Note that start_display will handle the case that the
 16780              line starting at tlbufpos is a continuation line.  */
 16781           start_display (&it, w, tlbufpos);
 16782 
 16783           /* Implementation note: It this still necessary?  */
 16784           if (it.current_x != this_line_start_x)
 16785             goto cancel;
 16786 
 16787           /* Give up on this optimization if the line starts with a
 16788              string with display property that draws on the fringes,
 16789              as that might interfere with line-prefix display.  */
 16790           if (it.sp > 1
 16791               && it.method == GET_FROM_IMAGE && it.image_id == -1)
 16792             goto cancel;
 16793           redisplay_trace ("trying display optimization 1\n");
 16794           w->cursor.vpos = -1;
 16795           overlay_arrow_seen = false;
 16796           it.vpos = this_line_vpos;
 16797           it.current_y = this_line_y;
 16798           it.glyph_row = MATRIX_ROW (w->desired_matrix, this_line_vpos);
 16799           display_line (&it, -1);
 16800 
 16801           /* If line contains point, is not continued,
 16802              and ends at same distance from eob as before, we win.  */
 16803           if (w->cursor.vpos >= 0
 16804               /* Line is not continued, otherwise this_line_start_pos
 16805                  would have been set to 0 in display_line.  */
 16806               && CHARPOS (this_line_start_pos)
 16807               /* Line ends as before.  */
 16808               && CHARPOS (this_line_end_pos) == CHARPOS (tlendpos)
 16809               /* Line has same height as before.  Otherwise other lines
 16810                  would have to be shifted up or down.  */
 16811               && this_line_pixel_height == line_height_before
 16812               /* Cannot use this optimization if hscrolling current
 16813                  line and this line is the current one, because
 16814                  display_line above is not informed about the
 16815                  current-line's vpos, and cannot DTRT in that case.  */
 16816               && !hscrolling_current_line_p (w))
 16817             {
 16818               /* If this is not the window's last line, we must adjust
 16819                  the charstarts of the lines below.  */
 16820               if (it.current_y < it.last_visible_y)
 16821                 {
 16822                   struct glyph_row *row
 16823                     = MATRIX_ROW (w->current_matrix, this_line_vpos + 1);
 16824                   ptrdiff_t delta, delta_bytes;
 16825 
 16826                   /* We used to distinguish between two cases here,
 16827                      conditioned by Z - CHARPOS (tlendpos) == ZV, for
 16828                      when the line ends in a newline or the end of the
 16829                      buffer's accessible portion.  But both cases did
 16830                      the same, so they were collapsed.  */
 16831                   delta = (Z
 16832                            - CHARPOS (tlendpos)
 16833                            - MATRIX_ROW_START_CHARPOS (row));
 16834                   delta_bytes = (Z_BYTE
 16835                                  - BYTEPOS (tlendpos)
 16836                                  - MATRIX_ROW_START_BYTEPOS (row));
 16837 
 16838                   increment_matrix_positions (w->current_matrix,
 16839                                               this_line_vpos + 1,
 16840                                               w->current_matrix->nrows,
 16841                                               delta, delta_bytes);
 16842                 }
 16843 
 16844               /* If this row displays text now but previously didn't,
 16845                  or vice versa, w->window_end_vpos may have to be
 16846                  adjusted.  */
 16847               if (MATRIX_ROW_DISPLAYS_TEXT_P (it.glyph_row - 1))
 16848                 {
 16849                   if (w->window_end_vpos < this_line_vpos)
 16850                     w->window_end_vpos = this_line_vpos;
 16851                 }
 16852               else if (w->window_end_vpos == this_line_vpos
 16853                        && this_line_vpos > 0)
 16854                 w->window_end_vpos = this_line_vpos - 1;
 16855               w->window_end_valid = false;
 16856 
 16857               /* Update hint: No need to try to scroll in update_window.  */
 16858               w->desired_matrix->no_scrolling_p = true;
 16859 
 16860 #ifdef GLYPH_DEBUG
 16861               *w->desired_matrix->method = 0;
 16862               debug_method_add (w, "optimization 1");
 16863 #endif
 16864 #ifdef HAVE_WINDOW_SYSTEM
 16865               update_window_fringes (w, false);
 16866 #endif
 16867               goto update;
 16868             }
 16869           else
 16870             goto cancel;
 16871         }
 16872       else if (/* Cursor position hasn't changed.  */
 16873                PT == w->last_point
 16874                /* Make sure the cursor was last displayed
 16875                   in this window.  Otherwise we have to reposition it.  */
 16876 
 16877                /* PXW: Must be converted to pixels, probably.  */
 16878                && 0 <= w->cursor.vpos
 16879                && w->cursor.vpos < WINDOW_TOTAL_LINES (w))
 16880         {
 16881           if (!must_finish)
 16882             {
 16883               do_pending_window_change (true);
 16884               /* If selected_window changed, redisplay again.  */
 16885               if (WINDOWP (selected_window)
 16886                   && (w = XWINDOW (selected_window)) != sw)
 16887                 goto retry;
 16888 
 16889                 /* We used to always goto end_of_redisplay here, but this
 16890                  isn't enough if we have a blinking cursor.  */
 16891               if (w->cursor_off_p == w->last_cursor_off_p)
 16892                 goto end_of_redisplay;
 16893             }
 16894           goto update;
 16895         }
 16896       /* If highlighting the region, or if the cursor is in the echo area,
 16897          then we can't just move the cursor.  */
 16898       else if (NILP (Vshow_trailing_whitespace)
 16899                && !cursor_in_echo_area
 16900                && !composition_break_at_point)
 16901         {
 16902           struct it it;
 16903           struct glyph_row *row;
 16904 
 16905           /* Skip from tlbufpos to PT and see where it is.  Note that
 16906              PT may be in invisible text.  If so, we will end at the
 16907              next visible position.  */
 16908           init_iterator (&it, w, CHARPOS (tlbufpos), BYTEPOS (tlbufpos),
 16909                          NULL, DEFAULT_FACE_ID);
 16910           it.current_x = this_line_start_x;
 16911           it.current_y = this_line_y;
 16912           it.vpos = this_line_vpos;
 16913 
 16914           if (current_buffer->long_line_optimizations_p
 16915               && it.line_wrap == TRUNCATE
 16916               && PT - CHARPOS (tlbufpos) > large_hscroll_threshold)
 16917             {
 16918               /* When lines are very long and truncated, jumping to
 16919                  the next visible line is much faster than slowly
 16920                  iterating there.  */
 16921               reseat_at_next_visible_line_start (&it, false);
 16922               if (IT_CHARPOS (it) <= PT) /* point moved off this line */
 16923                 it.vpos = this_line_vpos + 1;
 16924             }
 16925           else
 16926             {
 16927               /* The call to move_it_to stops in front of PT, but
 16928                  moves over before-strings.  */
 16929               move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
 16930             }
 16931 
 16932           if (it.vpos == this_line_vpos
 16933               && (row = MATRIX_ROW (w->current_matrix, this_line_vpos),
 16934                   row->enabled_p))
 16935             {
 16936               eassert (this_line_vpos == it.vpos);
 16937               eassert (this_line_y == it.current_y);
 16938               set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
 16939               if (cursor_row_fully_visible_p (w, false, true, false))
 16940                 {
 16941 #ifdef GLYPH_DEBUG
 16942                   *w->desired_matrix->method = 0;
 16943                   debug_method_add (w, "optimization 3");
 16944 #endif
 16945                   goto update;
 16946                 }
 16947               else
 16948                 goto cancel;
 16949             }
 16950           else
 16951             goto cancel;
 16952         }
 16953 
 16954     cancel:
 16955       /* Text changed drastically or point moved off of line.  */
 16956       SET_MATRIX_ROW_ENABLED_P (w->desired_matrix, this_line_vpos, false);
 16957     }
 16958 
 16959   CHARPOS (this_line_start_pos) = 0;
 16960   ++clear_face_cache_count;
 16961 #ifdef HAVE_WINDOW_SYSTEM
 16962   ++clear_image_cache_count;
 16963 #endif
 16964 
 16965   /* Build desired matrices, and update the display.  If
 16966      consider_all_windows_p, do it for all windows on all frames that
 16967      require redisplay, as specified by their 'redisplay' flag.
 16968      Otherwise do it for selected_window, only.  */
 16969 
 16970   if (consider_all_windows_p)
 16971     {
 16972       FOR_EACH_FRAME (tail, frame)
 16973         XFRAME (frame)->updated_p = false;
 16974 
 16975       propagate_buffer_redisplay ();
 16976 
 16977       FOR_EACH_FRAME (tail, frame)
 16978         {
 16979           struct frame *f = XFRAME (frame);
 16980 
 16981           /* We don't have to do anything for unselected terminal
 16982              frames.  */
 16983           if ((FRAME_TERMCAP_P (f) || FRAME_MSDOS_P (f))
 16984               && !EQ (FRAME_TTY (f)->top_frame, frame))
 16985             continue;
 16986 
 16987         retry_frame:
 16988           if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
 16989             {
 16990               bool gcscrollbars
 16991                 /* Only GC scrollbars when we redisplay the whole frame.  */
 16992                 = f->redisplay || !REDISPLAY_SOME_P ();
 16993               bool f_redisplay_flag = f->redisplay;
 16994 
 16995               /* The X error handler may have deleted that frame
 16996                  before we went back to retry_frame.  This must come
 16997                  before any accesses to f->terminal.  */
 16998               if (!FRAME_LIVE_P (f))
 16999                 continue;
 17000 
 17001               /* Mark all the scroll bars to be removed; we'll redeem
 17002                  the ones we want when we redisplay their windows.  */
 17003               if (gcscrollbars && FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
 17004                 FRAME_TERMINAL (f)->condemn_scroll_bars_hook (f);
 17005 
 17006               if (FRAME_REDISPLAY_P (f) && !FRAME_OBSCURED_P (f))
 17007                 {
 17008                   /* Don't allow freeing images and faces for this
 17009                      frame as long as the frame's update wasn't
 17010                      completed.  This prevents crashes when some Lisp
 17011                      that runs from the various hooks or font-lock
 17012                      decides to clear the frame's image cache and face
 17013                      cache, when the images and faces in those caches
 17014                      are referenced by the desired matrix.  */
 17015                   f->inhibit_clear_image_cache = true;
 17016                   redisplay_windows (FRAME_ROOT_WINDOW (f));
 17017                 }
 17018               /* Remember that the invisible frames need to be redisplayed next
 17019                  time they're visible.  */
 17020               else if (!REDISPLAY_SOME_P ())
 17021                 f->redisplay = true;
 17022 
 17023               /* The X error handler may have deleted that frame.  */
 17024               if (!FRAME_LIVE_P (f))
 17025                 continue;
 17026 
 17027               /* Any scroll bars which redisplay_windows should have
 17028                  nuked should now go away.  */
 17029               if (gcscrollbars && FRAME_TERMINAL (f)->judge_scroll_bars_hook)
 17030                 FRAME_TERMINAL (f)->judge_scroll_bars_hook (f);
 17031 
 17032               if (FRAME_REDISPLAY_P (f) && !FRAME_OBSCURED_P (f))
 17033                 {
 17034                   /* If fonts changed on visible frame, display again.  */
 17035                   if (f->fonts_changed)
 17036                     {
 17037                       adjust_frame_glyphs (f);
 17038                       /* Disable all redisplay optimizations for this
 17039                          frame.  For the reasons, see the comment near
 17040                          the previous call to adjust_frame_glyphs above.  */
 17041                       SET_FRAME_GARBAGED (f);
 17042                       f->fonts_changed = false;
 17043                       goto retry_frame;
 17044                     }
 17045 
 17046                   /* See if we have to hscroll.  */
 17047                   if (!f->already_hscrolled_p)
 17048                     {
 17049                       f->already_hscrolled_p = true;
 17050                       if (hscroll_retries <= MAX_HSCROLL_RETRIES
 17051                           && hscroll_windows (f->root_window))
 17052                         {
 17053                           hscroll_retries++;
 17054                           goto retry_frame;
 17055                         }
 17056                     }
 17057 
 17058                   /* If the frame's redisplay flag was not set before
 17059                      we went about redisplaying its windows, but it is
 17060                      set now, that means we employed some redisplay
 17061                      optimizations inside redisplay_windows, and
 17062                      bypassed producing some screen lines.  But if
 17063                      f->redisplay is now set, it might mean the old
 17064                      faces are no longer valid (e.g., if redisplaying
 17065                      some window called some Lisp which defined a new
 17066                      face or redefined an existing face), so trying to
 17067                      use them in update_frame will segfault.
 17068                      Therefore, we must redisplay this frame.  */
 17069                   if (!f_redisplay_flag && f->redisplay)
 17070                     goto retry_frame;
 17071                   /* In some case (e.g., window resize), we notice
 17072                      only during window updating that the window
 17073                      content changed unpredictably (e.g., a GTK
 17074                      scrollbar moved, or some Lisp hook that winds up
 17075                      calling adjust_frame_glyphs) and that our
 17076                      previous estimation of the frame content was
 17077                      garbage.  We have to start over.  These cases
 17078                      should be rare, so going all the way back to the
 17079                      top of redisplay should be good enough.  */
 17080                   if (FRAME_GARBAGED_P (f)
 17081                       && garbaged_frame_retries++ < MAX_GARBAGED_FRAME_RETRIES)
 17082                     goto retry;
 17083 
 17084 #ifdef HAVE_WINDOW_SYSTEM
 17085                   if (FRAME_WINDOW_P (f)
 17086                       && FRAME_RIF (f)->clear_under_internal_border)
 17087                     FRAME_RIF (f)->clear_under_internal_border (f);
 17088 #endif
 17089                   /* Prevent various kinds of signals during display
 17090                      update.  stdio is not robust about handling
 17091                      signals, which can cause an apparent I/O error.  */
 17092                   if (interrupt_input)
 17093                     unrequest_sigio ();
 17094                   STOP_POLLING;
 17095 
 17096                   pending |= update_frame (f, false, false);
 17097                   /* On some platforms (at least MS-Windows), the
 17098                      scroll_run_hook called from scrolling_window
 17099                      called from update_frame could set the frame's
 17100                      garbaged flag, in which case we need to redisplay
 17101                      the frame.  Don't do that on TTY frames, since we
 17102                      need to keep the garbaged flag in that case when
 17103                      the frame has been resized.  */
 17104                   if (FRAME_GARBAGED_P (f))
 17105                     {
 17106                       fset_redisplay (f);
 17107                       f->garbaged = false;
 17108                       goto retry_frame;
 17109                     }
 17110                   f->cursor_type_changed = false;
 17111                   f->updated_p = true;
 17112                   f->inhibit_clear_image_cache = false;
 17113                 }
 17114             }
 17115         }
 17116 
 17117       eassert (EQ (XFRAME (selected_frame)->selected_window, selected_window));
 17118 
 17119       if (!pending)
 17120         {
 17121           /* Do the mark_window_display_accurate after all windows have
 17122              been redisplayed because this call resets flags in buffers
 17123              which are needed for proper redisplay.  */
 17124           FOR_EACH_FRAME (tail, frame)
 17125             {
 17126               struct frame *f = XFRAME (frame);
 17127               if (f->updated_p)
 17128                 {
 17129                   f->redisplay = false;
 17130                   f->garbaged = false;
 17131                   mark_window_display_accurate (f->root_window, true);
 17132                   if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
 17133                     FRAME_TERMINAL (f)->frame_up_to_date_hook (f);
 17134                 }
 17135             }
 17136         }
 17137     }
 17138   else if (FRAME_REDISPLAY_P (sf) && !FRAME_OBSCURED_P (sf))
 17139     {
 17140       sf->inhibit_clear_image_cache = true;
 17141       displayed_buffer = XBUFFER (XWINDOW (selected_window)->contents);
 17142       /* Use list_of_error, not Qerror, so that
 17143          we catch only errors and don't run the debugger.  */
 17144       internal_condition_case_1 (redisplay_window_1, selected_window,
 17145                                  list_of_error,
 17146                                  redisplay_window_error);
 17147       if (update_miniwindow_p)
 17148         {
 17149           Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
 17150 
 17151           displayed_buffer = XBUFFER (XWINDOW (mini_window)->contents);
 17152           internal_condition_case_1 (redisplay_window_1, mini_window,
 17153                                      list_of_error,
 17154                                      redisplay_window_error);
 17155         }
 17156 
 17157       /* Compare desired and current matrices, perform output.  */
 17158 
 17159     update:
 17160       /* If fonts changed, display again.  Likewise if redisplay_window_1
 17161          above caused some change (e.g., a change in faces) that requires
 17162          considering the entire frame again.  */
 17163       if (sf->fonts_changed || sf->redisplay)
 17164         {
 17165           if (sf->redisplay)
 17166             {
 17167               /* Set this to force a more thorough redisplay.
 17168                  Otherwise, we might immediately loop back to the
 17169                  above "else-if" clause (since all the conditions that
 17170                  led here might still be true), and we will then
 17171                  infloop, because the selected-frame's redisplay flag
 17172                  is not (and cannot be) reset.  */
 17173               windows_or_buffers_changed = 50;
 17174             }
 17175           goto retry;
 17176         }
 17177 
 17178       /* Prevent freeing of realized faces, since desired matrices are
 17179          pending that reference the faces we computed and cached.  */
 17180       inhibit_free_realized_faces = true;
 17181 
 17182       /* Prevent various kinds of signals during display update.
 17183          stdio is not robust about handling signals,
 17184          which can cause an apparent I/O error.  */
 17185       if (interrupt_input)
 17186         unrequest_sigio ();
 17187       STOP_POLLING;
 17188 
 17189       if (FRAME_REDISPLAY_P (sf) && !FRAME_OBSCURED_P (sf))
 17190         {
 17191           if (hscroll_retries <= MAX_HSCROLL_RETRIES
 17192               && hscroll_windows (selected_window))
 17193             {
 17194               hscroll_retries++;
 17195               goto retry;
 17196             }
 17197 
 17198           XWINDOW (selected_window)->must_be_updated_p = true;
 17199           pending = update_frame (sf, false, false);
 17200           sf->cursor_type_changed = false;
 17201           sf->inhibit_clear_image_cache = false;
 17202         }
 17203 
 17204       /* We may have called echo_area_display at the top of this
 17205          function.  If the echo area is on another frame, that may
 17206          have put text on a frame other than the selected one, so the
 17207          above call to update_frame would not have caught it.  Catch
 17208          it here.  */
 17209       Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
 17210       struct frame *mini_frame = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 17211 
 17212       if (mini_frame != sf && FRAME_WINDOW_P (mini_frame))
 17213         {
 17214           XWINDOW (mini_window)->must_be_updated_p = true;
 17215           pending |= update_frame (mini_frame, false, false);
 17216           mini_frame->cursor_type_changed = false;
 17217           if (!pending && hscroll_retries <= MAX_HSCROLL_RETRIES
 17218               && hscroll_windows (mini_window))
 17219             {
 17220               hscroll_retries++;
 17221               goto retry;
 17222             }
 17223         }
 17224     }
 17225 
 17226   /* If display was paused because of pending input, make sure we do a
 17227      thorough update the next time.  */
 17228   if (pending)
 17229     {
 17230       /* Prevent the optimization at the beginning of
 17231          redisplay_internal that tries a single-line update of the
 17232          line containing the cursor in the selected window.  */
 17233       CHARPOS (this_line_start_pos) = 0;
 17234 
 17235       /* Let the overlay arrow be updated the next time.  */
 17236       update_overlay_arrows (0);
 17237 
 17238       /* If we pause after scrolling, some rows in the current
 17239          matrices of some windows are not valid.  */
 17240       if (!WINDOW_FULL_WIDTH_P (w)
 17241           && !FRAME_WINDOW_P (XFRAME (w->frame)))
 17242         update_mode_lines = 36;
 17243     }
 17244   else
 17245     {
 17246       if (!consider_all_windows_p)
 17247         {
 17248           /* This has already been done above if
 17249              consider_all_windows_p is set.  */
 17250           if (XBUFFER (w->contents)->text->redisplay
 17251               && buffer_window_count (XBUFFER (w->contents)) > 1)
 17252             /* This can happen if b->text->redisplay was set during
 17253                jit-lock.  */
 17254             propagate_buffer_redisplay ();
 17255           mark_window_display_accurate_1 (w, true);
 17256 
 17257           /* Say overlay arrows are up to date.  */
 17258           update_overlay_arrows (1);
 17259 
 17260           if (FRAME_TERMINAL (sf)->frame_up_to_date_hook != 0)
 17261             FRAME_TERMINAL (sf)->frame_up_to_date_hook (sf);
 17262         }
 17263 
 17264       update_mode_lines = 0;
 17265       windows_or_buffers_changed = 0;
 17266     }
 17267 
 17268   /* Start SIGIO interrupts coming again.  Having them off during the
 17269      code above makes it less likely one will discard output, but not
 17270      impossible, since there might be stuff in the system buffer here.
 17271      But it is much hairier to try to do anything about that.  */
 17272   if (interrupt_input)
 17273     request_sigio ();
 17274   RESUME_POLLING;
 17275 
 17276   /* If a frame has become visible which was not before, redisplay
 17277      again, so that we display it.  Expose events for such a frame
 17278      (which it gets when becoming visible) don't call the parts of
 17279      redisplay constructing glyphs, so simply exposing a frame won't
 17280      display anything in this case.  So, we have to display these
 17281      frames here explicitly.  */
 17282   if (!pending)
 17283     {
 17284       int new_count = 0;
 17285 
 17286       FOR_EACH_FRAME (tail, frame)
 17287         {
 17288           if (FRAME_REDISPLAY_P (XFRAME (frame)))
 17289             new_count++;
 17290         }
 17291 
 17292       if (new_count != number_of_visible_frames)
 17293         windows_or_buffers_changed = 52;
 17294     }
 17295 
 17296   /* Change frame size now if a change is pending.  */
 17297   do_pending_window_change (true);
 17298 
 17299   /* If we just did a pending size change, or have additional
 17300      visible frames, or selected_window changed, redisplay again.  */
 17301   if ((windows_or_buffers_changed && !pending)
 17302       || (WINDOWP (selected_window)
 17303           && (w = XWINDOW (selected_window)) != sw))
 17304     goto retry;
 17305 
 17306   /* Clear the face and image caches.
 17307 
 17308      We used to do this only if consider_all_windows_p.  But the cache
 17309      needs to be cleared if a timer creates images in the current
 17310      buffer (e.g. the test case in Bug#6230).  */
 17311 
 17312   if (clear_face_cache_count > CLEAR_FACE_CACHE_COUNT)
 17313     {
 17314       clear_face_cache (false);
 17315       clear_face_cache_count = 0;
 17316     }
 17317 
 17318 #ifdef HAVE_WINDOW_SYSTEM
 17319   if (clear_image_cache_count > CLEAR_IMAGE_CACHE_COUNT)
 17320     {
 17321       clear_image_caches (Qnil);
 17322       clear_image_cache_count = 0;
 17323     }
 17324 #endif /* HAVE_WINDOW_SYSTEM */
 17325 
 17326  end_of_redisplay:
 17327 #ifdef HAVE_NS
 17328   ns_set_doc_edited ();
 17329 #endif
 17330   if (interrupt_input && interrupts_deferred)
 17331     request_sigio ();
 17332 
 17333   /* We're done with this redisplay cycle, so reset the tick count in
 17334      preparation for the next redisplay cycle.  */
 17335   if (max_redisplay_ticks > 0)
 17336     update_redisplay_ticks (0, NULL);
 17337 
 17338   unbind_to (count, Qnil);
 17339   RESUME_POLLING;
 17340 }
 17341 
 17342 static void
 17343 unwind_redisplay_preserve_echo_area (void)
 17344 {
 17345   unblock_buffer_flips ();
 17346 }
 17347 
 17348 /* Redisplay, but leave alone any recent echo area message unless
 17349    another message has been requested in its place.
 17350 
 17351    This is useful in situations where you need to redisplay but no
 17352    user action has occurred, making it inappropriate for the message
 17353    area to be cleared.  See tracking_off and
 17354    wait_reading_process_output for examples of these situations.
 17355 
 17356    FROM_WHERE is an integer saying from where this function was
 17357    called.  This is useful for debugging.  */
 17358 
 17359 void
 17360 redisplay_preserve_echo_area (int from_where)
 17361 {
 17362   redisplay_trace ("redisplay_preserve_echo_area (%d)\n", from_where);
 17363 
 17364   block_input ();
 17365   specpdl_ref count = SPECPDL_INDEX ();
 17366   record_unwind_protect_void (unwind_redisplay_preserve_echo_area);
 17367   block_buffer_flips ();
 17368   unblock_input ();
 17369 
 17370   if (!NILP (echo_area_buffer[1]))
 17371     {
 17372       /* We have a previously displayed message, but no current
 17373          message.  Redisplay the previous message.  */
 17374       display_last_displayed_message_p = true;
 17375       redisplay_internal ();
 17376       display_last_displayed_message_p = false;
 17377     }
 17378   else
 17379     redisplay_internal ();
 17380 
 17381   flush_frame (SELECTED_FRAME ());
 17382   unbind_to (count, Qnil);
 17383 }
 17384 
 17385 
 17386 /* Function registered with record_unwind_protect in redisplay_internal.  */
 17387 
 17388 static void
 17389 unwind_redisplay (void)
 17390 {
 17391   redisplaying_p = false;
 17392   unblock_buffer_flips ();
 17393 }
 17394 
 17395 /* Function registered with record_unwind_protect before calling
 17396    start_display outside of redisplay_internal.  */
 17397 void
 17398 unwind_display_working_on_window (void)
 17399 {
 17400   display_working_on_window_p = false;
 17401 }
 17402 
 17403 /* Mark the display of leaf window W as accurate or inaccurate.
 17404    If ACCURATE_P, mark display of W as accurate.
 17405    If !ACCURATE_P, arrange for W to be redisplayed the next
 17406    time redisplay_internal is called.  */
 17407 
 17408 static void
 17409 mark_window_display_accurate_1 (struct window *w, bool accurate_p)
 17410 {
 17411   struct buffer *b = XBUFFER (w->contents);
 17412 
 17413   w->last_modified = accurate_p ? BUF_MODIFF (b) : 0;
 17414   w->last_overlay_modified = accurate_p ? BUF_OVERLAY_MODIFF (b) : 0;
 17415   w->last_had_star = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b);
 17416 
 17417   if (accurate_p)
 17418     {
 17419       b->clip_changed = false;
 17420       b->prevent_redisplay_optimizations_p = false;
 17421       eassert (buffer_window_count (b) > 0);
 17422       /* Resetting b->text->redisplay is problematic!
 17423          In order to make it safer to do it here, redisplay_internal must
 17424          have copied all b->text->redisplay to their respective windows.  */
 17425       b->text->redisplay = false;
 17426 
 17427       BUF_UNCHANGED_MODIFIED (b) = BUF_MODIFF (b);
 17428       BUF_OVERLAY_UNCHANGED_MODIFIED (b) = BUF_OVERLAY_MODIFF (b);
 17429       BUF_BEG_UNCHANGED (b) = BUF_GPT (b) - BUF_BEG (b);
 17430       BUF_END_UNCHANGED (b) = BUF_Z (b) - BUF_GPT (b);
 17431 
 17432       w->current_matrix->buffer = b;
 17433       w->current_matrix->begv = BUF_BEGV (b);
 17434       w->current_matrix->zv = BUF_ZV (b);
 17435       w->current_matrix->header_line_p = window_wants_header_line (w);
 17436       w->current_matrix->tab_line_p = window_wants_tab_line (w);
 17437 
 17438       w->last_cursor_vpos = w->cursor.vpos;
 17439       w->last_cursor_off_p = w->cursor_off_p;
 17440 
 17441       if (w == XWINDOW (selected_window))
 17442         w->last_point = BUF_PT (b);
 17443       else
 17444         w->last_point = marker_position (w->pointm);
 17445 
 17446       w->window_end_valid = true;
 17447       w->update_mode_line = false;
 17448       w->preserve_vscroll_p = false;
 17449     }
 17450 
 17451   w->redisplay = !accurate_p;
 17452 }
 17453 
 17454 
 17455 /* Mark the display of windows in the window tree rooted at WINDOW as
 17456    accurate or inaccurate.  If ACCURATE_P, mark display of
 17457    windows as accurate.  If !ACCURATE_P, arrange for windows to
 17458    be redisplayed the next time redisplay_internal is called.  */
 17459 
 17460 void
 17461 mark_window_display_accurate (Lisp_Object window, bool accurate_p)
 17462 {
 17463   struct window *w;
 17464 
 17465   for (; !NILP (window); window = w->next)
 17466     {
 17467       w = XWINDOW (window);
 17468       if (WINDOWP (w->contents))
 17469         mark_window_display_accurate (w->contents, accurate_p);
 17470       else
 17471         mark_window_display_accurate_1 (w, accurate_p);
 17472     }
 17473 
 17474   if (accurate_p)
 17475     update_overlay_arrows (1);
 17476   else
 17477     /* Force a thorough redisplay the next time by setting
 17478        last_arrow_position and last_arrow_string to t, which is
 17479        unequal to any useful value of Voverlay_arrow_...  */
 17480     update_overlay_arrows (-1);
 17481 }
 17482 
 17483 
 17484 /* Return value in display table DP (Lisp_Char_Table *) for character
 17485    C.  Since a display table doesn't have any parent, we don't have to
 17486    follow parent.  Do not call this function directly but use the
 17487    macro DISP_CHAR_VECTOR.  */
 17488 
 17489 Lisp_Object
 17490 disp_char_vector (struct Lisp_Char_Table *dp, int c)
 17491 {
 17492   Lisp_Object val;
 17493 
 17494   if (ASCII_CHAR_P (c))
 17495     {
 17496       val = dp->ascii;
 17497       if (SUB_CHAR_TABLE_P (val))
 17498         val = XSUB_CHAR_TABLE (val)->contents[c];
 17499     }
 17500   else
 17501     {
 17502       Lisp_Object table;
 17503 
 17504       XSETCHAR_TABLE (table, dp);
 17505       val = char_table_ref (table, c);
 17506     }
 17507   if (NILP (val))
 17508     val = dp->defalt;
 17509   return val;
 17510 }
 17511 
 17512 static int buffer_flip_blocked_depth;
 17513 
 17514 static void
 17515 block_buffer_flips (void)
 17516 {
 17517   eassert (buffer_flip_blocked_depth >= 0);
 17518   buffer_flip_blocked_depth++;
 17519 }
 17520 
 17521 static void
 17522 unblock_buffer_flips (void)
 17523 {
 17524   eassert (buffer_flip_blocked_depth > 0);
 17525   if (--buffer_flip_blocked_depth == 0)
 17526     {
 17527       Lisp_Object tail, frame;
 17528       block_input ();
 17529       FOR_EACH_FRAME (tail, frame)
 17530         {
 17531           struct frame *f = XFRAME (frame);
 17532           if (FRAME_TERMINAL (f)->buffer_flipping_unblocked_hook)
 17533             (*FRAME_TERMINAL (f)->buffer_flipping_unblocked_hook) (f);
 17534         }
 17535       unblock_input ();
 17536     }
 17537 }
 17538 
 17539 bool
 17540 buffer_flipping_blocked_p (void)
 17541 {
 17542   return buffer_flip_blocked_depth > 0;
 17543 }
 17544 
 17545 
 17546 /***********************************************************************
 17547                            Window Redisplay
 17548  ***********************************************************************/
 17549 
 17550 /* Redisplay all leaf windows in the window tree rooted at WINDOW.  */
 17551 
 17552 static void
 17553 redisplay_windows (Lisp_Object window)
 17554 {
 17555   while (!NILP (window))
 17556     {
 17557       struct window *w = XWINDOW (window);
 17558 
 17559       if (WINDOWP (w->contents))
 17560         redisplay_windows (w->contents);
 17561       else if (BUFFERP (w->contents))
 17562         {
 17563           displayed_buffer = XBUFFER (w->contents);
 17564           /* Use list_of_error, not Qerror, so that
 17565              we catch only errors and don't run the debugger.  */
 17566           internal_condition_case_1 (redisplay_window_0, window,
 17567                                      list_of_error,
 17568                                      redisplay_window_error);
 17569         }
 17570 
 17571       window = w->next;
 17572     }
 17573 }
 17574 
 17575 static Lisp_Object
 17576 redisplay_window_error (Lisp_Object error_data)
 17577 {
 17578   displayed_buffer->display_error_modiff = BUF_MODIFF (displayed_buffer);
 17579 
 17580   /* When in redisplay, the error is captured and not shown.  Arrange
 17581      for it to be shown later.  */
 17582   if (max_redisplay_ticks > 0
 17583       && CONSP (error_data)
 17584       && EQ (XCAR (error_data), Qerror)
 17585       && STRINGP (XCAR (XCDR (error_data))))
 17586     Vdelayed_warnings_list = Fcons (list2 (XCAR (error_data),
 17587                                            XCAR (XCDR (error_data))),
 17588                                     Vdelayed_warnings_list);
 17589   return Qnil;
 17590 }
 17591 
 17592 static Lisp_Object
 17593 redisplay_window_0 (Lisp_Object window)
 17594 {
 17595   if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
 17596     redisplay_window (window, false);
 17597   return Qnil;
 17598 }
 17599 
 17600 static Lisp_Object
 17601 redisplay_window_1 (Lisp_Object window)
 17602 {
 17603   if (displayed_buffer->display_error_modiff < BUF_MODIFF (displayed_buffer))
 17604     redisplay_window (window, true);
 17605   return Qnil;
 17606 }
 17607 
 17608 
 17609 /***********************************************************************
 17610                       Aborting runaway redisplay
 17611  ***********************************************************************/
 17612 
 17613 /* Update the redisplay-tick count for window W, and signal an error
 17614    if the tick count is above some threshold, indicating that
 17615    redisplay of the window takes "too long".
 17616 
 17617    TICKS is the amount of ticks to add to the W's current count; zero
 17618    means to initialize the tick count to zero.
 17619 
 17620    W can be NULL if TICKS is zero: that means unconditionally
 17621    re-initialize the current tick count to zero.
 17622 
 17623    W can also be NULL if the caller doesn't know which window is being
 17624    processed by the display code.  In that case, if TICKS is non-zero,
 17625    we assume it's the last window that shows the current buffer.  */
 17626 void
 17627 update_redisplay_ticks (int ticks, struct window *w)
 17628 {
 17629   /* This keeps track of the window on which redisplay is working.  */
 17630   static struct window *cwindow;
 17631   static EMACS_INT window_ticks;
 17632 
 17633   /* We only initialize the count if this is a different window or
 17634      NULL.  Otherwise, this is a call from init_iterator for the same
 17635      window we tracked before, and we should keep the count.  */
 17636   if (!ticks && w != cwindow)
 17637     {
 17638       cwindow = w;
 17639       window_ticks = 0;
 17640     }
 17641   /* Some callers can be run in contexts unrelated to display code, so
 17642      don't abort them and don't update the tick count in those cases.  */
 17643   if ((!w && !redisplaying_p && !display_working_on_window_p)
 17644       /* We never disable redisplay of a mini-window, since that is
 17645          absolutely essential for communicating with Emacs.  */
 17646       || (w && MINI_WINDOW_P (w)))
 17647     return;
 17648 
 17649   if (ticks > 0)
 17650     window_ticks += ticks;
 17651   if (max_redisplay_ticks > 0 && window_ticks > max_redisplay_ticks)
 17652     {
 17653       /* In addition to a buffer, this could be a window (for non-leaf
 17654          windows, not expected here) or nil (for pseudo-windows like
 17655          the one used for the native tool bar).  */
 17656       Lisp_Object contents = w ? w->contents : Qnil;
 17657       char *bufname =
 17658         NILP (contents)
 17659         ? SSDATA (BVAR (current_buffer, name))
 17660         : (BUFFERP (contents)
 17661            ? SSDATA (BVAR (XBUFFER (contents), name))
 17662            : (char *) "<unknown>");
 17663 
 17664       windows_or_buffers_changed = 177;
 17665       /* scrolling_window depends too much on the glyph matrices being
 17666          correct, and we cannot guarantee that if we abort the
 17667          redisplay of this window.  */
 17668       if (w && w->desired_matrix)
 17669         w->desired_matrix->no_scrolling_p = true;
 17670       error ("Window showing buffer %s takes too long to redisplay", bufname);
 17671     }
 17672 }
 17673 
 17674 
 17675 
 17676 /* Set cursor position of W.  PT is assumed to be displayed in ROW.
 17677    DELTA and DELTA_BYTES are the numbers of characters and bytes by
 17678    which positions recorded in ROW differ from current buffer
 17679    positions.
 17680 
 17681    Return true iff cursor is on this row.  */
 17682 
 17683 static bool
 17684 set_cursor_from_row (struct window *w, struct glyph_row *row,
 17685                      struct glyph_matrix *matrix,
 17686                      ptrdiff_t delta, ptrdiff_t delta_bytes,
 17687                      int dy, int dvpos)
 17688 {
 17689   struct glyph *glyph = row->glyphs[TEXT_AREA];
 17690   struct glyph *end = glyph + row->used[TEXT_AREA];
 17691   struct glyph *cursor = NULL;
 17692   /* The last known character position in row.  */
 17693   ptrdiff_t last_pos = MATRIX_ROW_START_CHARPOS (row) + delta;
 17694   int x = row->x;
 17695   ptrdiff_t pt_old = PT - delta;
 17696   ptrdiff_t pos_before = MATRIX_ROW_START_CHARPOS (row) + delta;
 17697   ptrdiff_t pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
 17698   struct glyph *glyph_before = glyph - 1, *glyph_after = end;
 17699   /* A glyph beyond the edge of TEXT_AREA which we should never
 17700      touch.  */
 17701   struct glyph *glyphs_end = end;
 17702   /* True means we've found a match for cursor position, but that
 17703      glyph has the avoid_cursor_p flag set.  */
 17704   bool match_with_avoid_cursor = false;
 17705   /* True means we've seen at least one glyph that came from a
 17706      display string.  */
 17707   bool string_seen = false;
 17708   /* Largest and smallest buffer positions seen so far during scan of
 17709      glyph row.  */
 17710   ptrdiff_t bpos_max = pos_before;
 17711   ptrdiff_t bpos_min = pos_after;
 17712   /* Last buffer position covered by an overlay string with an integer
 17713      `cursor' property.  */
 17714   ptrdiff_t bpos_covered = 0;
 17715   /* True means the display string on which to display the cursor
 17716      comes from a text property, not from an overlay.  */
 17717   bool string_from_text_prop = false;
 17718 
 17719   /* Don't even try doing anything if called for a mode-line or
 17720      header-line or tab-line row, since the rest of the code isn't
 17721      prepared to deal with such calamities.  */
 17722   eassert (!row->mode_line_p);
 17723   if (row->mode_line_p)
 17724     return false;
 17725 
 17726   /* Skip over glyphs not having an object at the start and the end of
 17727      the row.  These are special glyphs like truncation marks on
 17728      terminal frames.  */
 17729   if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 17730     {
 17731       if (!row->reversed_p)
 17732         {
 17733           while (glyph < end
 17734                  && NILP (glyph->object)
 17735                  && glyph->charpos < 0)
 17736             {
 17737               x += glyph->pixel_width;
 17738               ++glyph;
 17739             }
 17740           while (end > glyph
 17741                  && NILP ((end - 1)->object)
 17742                  /* CHARPOS is zero for blanks and stretch glyphs
 17743                     inserted by extend_face_to_end_of_line.  */
 17744                  && (end - 1)->charpos <= 0)
 17745             --end;
 17746           glyph_before = glyph - 1;
 17747           glyph_after = end;
 17748         }
 17749       else
 17750         {
 17751           struct glyph *g;
 17752 
 17753           /* If the glyph row is reversed, we need to process it from back
 17754              to front, so swap the edge pointers.  */
 17755           glyphs_end = end = glyph - 1;
 17756           glyph += row->used[TEXT_AREA] - 1;
 17757 
 17758           while (glyph > end + 1
 17759                  && NILP (glyph->object)
 17760                  && glyph->charpos < 0)
 17761             --glyph;
 17762           if (NILP (glyph->object) && glyph->charpos < 0)
 17763             --glyph;
 17764           /* By default, in reversed rows we put the cursor on the
 17765              rightmost (first in the reading order) glyph.  */
 17766           for (x = 0, g = end + 1; g < glyph; g++)
 17767             x += g->pixel_width;
 17768           while (end < glyph
 17769                  && NILP ((end + 1)->object)
 17770                  && (end + 1)->charpos <= 0)
 17771             ++end;
 17772           glyph_before = glyph + 1;
 17773           glyph_after = end;
 17774         }
 17775     }
 17776   else if (row->reversed_p)
 17777     {
 17778       /* In R2L rows that don't display text, put the cursor on the
 17779          rightmost glyph.  Case in point: an empty last line that is
 17780          part of an R2L paragraph.  */
 17781       cursor = end - 1;
 17782       /* Avoid placing the cursor on the last glyph of the row, where
 17783          on terminal frames we hold the vertical border between
 17784          adjacent windows.  */
 17785       if (!FRAME_WINDOW_P (WINDOW_XFRAME (w))
 17786           && !WINDOW_RIGHTMOST_P (w)
 17787           && cursor == row->glyphs[LAST_AREA] - 1)
 17788         cursor--;
 17789       x = -1;   /* will be computed below, at label compute_x */
 17790     }
 17791 
 17792   /* Step 1: Try to find the glyph whose character position
 17793      corresponds to point.  If that's not possible, find 2 glyphs
 17794      whose character positions are the closest to point, one before
 17795      point, the other after it.  */
 17796   if (!row->reversed_p)
 17797     while (/* not marched to end of glyph row */
 17798            glyph < end
 17799            /* glyph was not inserted by redisplay for internal purposes */
 17800            && !NILP (glyph->object))
 17801       {
 17802         if (BUFFERP (glyph->object))
 17803           {
 17804             ptrdiff_t dpos = glyph->charpos - pt_old;
 17805 
 17806             if (glyph->charpos > bpos_max)
 17807               bpos_max = glyph->charpos;
 17808             if (glyph->charpos < bpos_min)
 17809               bpos_min = glyph->charpos;
 17810             if (!glyph->avoid_cursor_p)
 17811               {
 17812                 /* If we hit point, we've found the glyph on which to
 17813                    display the cursor.  */
 17814                 if (dpos == 0)
 17815                   {
 17816                     match_with_avoid_cursor = false;
 17817                     break;
 17818                   }
 17819                 /* See if we've found a better approximation to
 17820                    POS_BEFORE or to POS_AFTER.  */
 17821                 if (0 > dpos && dpos > pos_before - pt_old)
 17822                   {
 17823                     pos_before = glyph->charpos;
 17824                     glyph_before = glyph;
 17825                   }
 17826                 else if (0 < dpos && dpos < pos_after - pt_old)
 17827                   {
 17828                     pos_after = glyph->charpos;
 17829                     glyph_after = glyph;
 17830                   }
 17831               }
 17832             else if (dpos == 0)
 17833               match_with_avoid_cursor = true;
 17834           }
 17835         else if (STRINGP (glyph->object))
 17836           {
 17837             Lisp_Object chprop;
 17838             ptrdiff_t glyph_pos = glyph->charpos;
 17839 
 17840             chprop = Fget_char_property (make_fixnum (glyph_pos), Qcursor,
 17841                                          glyph->object);
 17842             if (!NILP (chprop))
 17843               {
 17844                 /* If the string came from a `display' text property,
 17845                    look up the buffer position of that property and
 17846                    use that position to update bpos_max, as if we
 17847                    actually saw such a position in one of the row's
 17848                    glyphs.  This helps with supporting integer values
 17849                    of `cursor' property on the display string in
 17850                    situations where most or all of the row's buffer
 17851                    text is completely covered by display properties,
 17852                    so that no glyph with valid buffer positions is
 17853                    ever seen in the row.  */
 17854                 ptrdiff_t prop_pos =
 17855                   string_buffer_position_lim (glyph->object, pos_before,
 17856                                               pos_after, false);
 17857 
 17858                 if (prop_pos >= pos_before)
 17859                   bpos_max = prop_pos;
 17860               }
 17861             if (FIXNUMP (chprop))
 17862               {
 17863                 bpos_covered = bpos_max + XFIXNUM (chprop);
 17864                 /* If the `cursor' property covers buffer positions up
 17865                    to and including point, we should display cursor on
 17866                    this glyph.  Note that, if a `cursor' property on one
 17867                    of the string's characters has an integer value, we
 17868                    will break out of the loop below _before_ we get to
 17869                    the position match above.  IOW, integer values of
 17870                    the `cursor' property override the "exact match for
 17871                    point" strategy of positioning the cursor.  */
 17872                 /* Implementation note: bpos_max == pt_old when, e.g.,
 17873                    we are in an empty line, where bpos_max is set to
 17874                    MATRIX_ROW_START_CHARPOS, see above.  */
 17875                 if (bpos_max <= pt_old && bpos_covered >= pt_old)
 17876                   {
 17877                     cursor = glyph;
 17878                     break;
 17879                   }
 17880               }
 17881 
 17882             string_seen = true;
 17883           }
 17884         x += glyph->pixel_width;
 17885         ++glyph;
 17886       }
 17887   else if (glyph > end) /* row is reversed */
 17888     while (!NILP (glyph->object))
 17889       {
 17890         if (BUFFERP (glyph->object))
 17891           {
 17892             ptrdiff_t dpos = glyph->charpos - pt_old;
 17893 
 17894             if (glyph->charpos > bpos_max)
 17895               bpos_max = glyph->charpos;
 17896             if (glyph->charpos < bpos_min)
 17897               bpos_min = glyph->charpos;
 17898             if (!glyph->avoid_cursor_p)
 17899               {
 17900                 if (dpos == 0)
 17901                   {
 17902                     match_with_avoid_cursor = false;
 17903                     break;
 17904                   }
 17905                 if (0 > dpos && dpos > pos_before - pt_old)
 17906                   {
 17907                     pos_before = glyph->charpos;
 17908                     glyph_before = glyph;
 17909                   }
 17910                 else if (0 < dpos && dpos < pos_after - pt_old)
 17911                   {
 17912                     pos_after = glyph->charpos;
 17913                     glyph_after = glyph;
 17914                   }
 17915               }
 17916             else if (dpos == 0)
 17917               match_with_avoid_cursor = true;
 17918           }
 17919         else if (STRINGP (glyph->object))
 17920           {
 17921             Lisp_Object chprop;
 17922             ptrdiff_t glyph_pos = glyph->charpos;
 17923 
 17924             chprop = Fget_char_property (make_fixnum (glyph_pos), Qcursor,
 17925                                          glyph->object);
 17926             if (!NILP (chprop))
 17927               {
 17928                 ptrdiff_t prop_pos =
 17929                   string_buffer_position_lim (glyph->object, pos_before,
 17930                                               pos_after, false);
 17931 
 17932                 if (prop_pos >= pos_before)
 17933                   bpos_max = prop_pos;
 17934               }
 17935             if (FIXNUMP (chprop))
 17936               {
 17937                 bpos_covered = bpos_max + XFIXNUM (chprop);
 17938                 /* If the `cursor' property covers buffer positions up
 17939                    to and including point, we should display cursor on
 17940                    this glyph.  */
 17941                 if (bpos_max <= pt_old && bpos_covered >= pt_old)
 17942                   {
 17943                     cursor = glyph;
 17944                     break;
 17945                   }
 17946               }
 17947             string_seen = true;
 17948           }
 17949         --glyph;
 17950         if (glyph == glyphs_end) /* don't dereference outside TEXT_AREA */
 17951           {
 17952             x--;                /* can't use any pixel_width */
 17953             break;
 17954           }
 17955         x -= glyph->pixel_width;
 17956     }
 17957 
 17958   /* Step 2: If we didn't find an exact match for point, we need to
 17959      look for a proper place to put the cursor among glyphs between
 17960      GLYPH_BEFORE and GLYPH_AFTER.  */
 17961   if (!((row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
 17962         && BUFFERP (glyph->object) && glyph->charpos == pt_old)
 17963       && !(bpos_max <= pt_old && pt_old <= bpos_covered))
 17964     {
 17965       /* An empty line has a single glyph whose OBJECT is nil and
 17966          whose CHARPOS is the position of a newline on that line.
 17967          Note that on a TTY, there are more glyphs after that, which
 17968          were produced by extend_face_to_end_of_line, but their
 17969          CHARPOS is zero or negative.  */
 17970       bool empty_line_p =
 17971         ((row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
 17972          && NILP (glyph->object) && glyph->charpos > 0
 17973          /* On a TTY, continued and truncated rows also have a glyph at
 17974             their end whose OBJECT is nil and whose CHARPOS is
 17975             positive (the continuation and truncation glyphs), but such
 17976             rows are obviously not "empty".  */
 17977          && !(row->continued_p || row->truncated_on_right_p));
 17978 
 17979       if (row->ends_in_ellipsis_p && pos_after == last_pos)
 17980         {
 17981           ptrdiff_t ellipsis_pos;
 17982 
 17983           /* Scan back over the ellipsis glyphs.  */
 17984           if (!row->reversed_p)
 17985             {
 17986               ellipsis_pos = (glyph - 1)->charpos;
 17987               while (glyph > row->glyphs[TEXT_AREA]
 17988                      && (glyph - 1)->charpos == ellipsis_pos)
 17989                 glyph--, x -= glyph->pixel_width;
 17990               /* That loop always goes one position too far, including
 17991                  the glyph before the ellipsis.  So scan forward over
 17992                  that one.  */
 17993               x += glyph->pixel_width;
 17994               glyph++;
 17995             }
 17996           else  /* row is reversed */
 17997             {
 17998               ellipsis_pos = (glyph + 1)->charpos;
 17999               while (glyph < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
 18000                      && (glyph + 1)->charpos == ellipsis_pos)
 18001                 glyph++, x += glyph->pixel_width;
 18002               x -= glyph->pixel_width;
 18003               glyph--;
 18004             }
 18005         }
 18006       else if (match_with_avoid_cursor)
 18007         {
 18008           cursor = glyph_after;
 18009           x = -1;
 18010         }
 18011       else if (string_seen)
 18012         {
 18013           int incr = row->reversed_p ? -1 : +1;
 18014 
 18015           /* Need to find the glyph that came out of a string which is
 18016              present at point.  That glyph is somewhere between
 18017              GLYPH_BEFORE and GLYPH_AFTER, and it came from a string
 18018              positioned between POS_BEFORE and POS_AFTER in the
 18019              buffer.  */
 18020           struct glyph *start, *stop;
 18021           ptrdiff_t pos = pos_before;
 18022 
 18023           x = -1;
 18024 
 18025           /* If the row ends in a newline from a display string,
 18026              reordering could have moved the glyphs belonging to the
 18027              string out of the [GLYPH_BEFORE..GLYPH_AFTER] range.  So
 18028              in this case we extend the search to the last glyph in
 18029              the row that was not inserted by redisplay.  */
 18030           if (row->ends_in_newline_from_string_p)
 18031             {
 18032               glyph_after = end;
 18033               pos_after = MATRIX_ROW_END_CHARPOS (row) + delta;
 18034             }
 18035 
 18036           /* GLYPH_BEFORE and GLYPH_AFTER are the glyphs that
 18037              correspond to POS_BEFORE and POS_AFTER, respectively.  We
 18038              need START and STOP in the order that corresponds to the
 18039              row's direction as given by its reversed_p flag.  If the
 18040              directionality of characters between POS_BEFORE and
 18041              POS_AFTER is the opposite of the row's base direction,
 18042              these characters will have been reordered for display,
 18043              and we need to reverse START and STOP.  */
 18044           if (!row->reversed_p)
 18045             {
 18046               start = min (glyph_before, glyph_after);
 18047               stop = max (glyph_before, glyph_after);
 18048             }
 18049           else
 18050             {
 18051               start = max (glyph_before, glyph_after);
 18052               stop = min (glyph_before, glyph_after);
 18053             }
 18054           for (glyph = start + incr;
 18055                row->reversed_p ? glyph > stop : glyph < stop; )
 18056             {
 18057 
 18058               /* Any glyphs that come from the buffer are here because
 18059                  of bidi reordering.  Skip them, and only pay
 18060                  attention to glyphs that came from some string.  */
 18061               if (STRINGP (glyph->object))
 18062                 {
 18063                   Lisp_Object str;
 18064                   ptrdiff_t tem;
 18065                   /* If the display property covers the newline, we
 18066                      need to search for it one position farther.  */
 18067                   ptrdiff_t lim = pos_after
 18068                     + (pos_after == MATRIX_ROW_END_CHARPOS (row) + delta);
 18069 
 18070                   string_from_text_prop = false;
 18071                   str = glyph->object;
 18072                   tem = string_buffer_position_lim (str, pos, lim, false);
 18073                   if (tem == 0  /* from overlay */
 18074                       || pos <= tem)
 18075                     {
 18076                       /* If the string from which this glyph came is
 18077                          found in the buffer at point, or at position
 18078                          that is closer to point than pos_after, then
 18079                          we've found the glyph we've been looking for.
 18080                          If it comes from an overlay (tem == 0), and
 18081                          it has the `cursor' property on one of its
 18082                          glyphs, record that glyph as a candidate for
 18083                          displaying the cursor.  (As in the
 18084                          unidirectional version, we will display the
 18085                          cursor on the last candidate we find.)  */
 18086                       if (tem == 0
 18087                           || tem == pt_old
 18088                           || (tem - pt_old > 0 && tem < pos_after))
 18089                         {
 18090                           /* The glyphs from this string could have
 18091                              been reordered.  Find the one with the
 18092                              smallest string position.  Or there could
 18093                              be a character in the string with the
 18094                              `cursor' property, which means display
 18095                              cursor on that character's glyph.  */
 18096                           ptrdiff_t strpos = glyph->charpos;
 18097 
 18098                           if (tem)
 18099                             {
 18100                               cursor = glyph;
 18101                               string_from_text_prop = true;
 18102                             }
 18103                           for ( ;
 18104                                (row->reversed_p ? glyph > stop : glyph < stop)
 18105                                  && EQ (glyph->object, str);
 18106                                glyph += incr)
 18107                             {
 18108                               Lisp_Object cprop;
 18109                               ptrdiff_t gpos = glyph->charpos;
 18110 
 18111                               cprop = Fget_char_property (make_fixnum (gpos),
 18112                                                           Qcursor,
 18113                                                           glyph->object);
 18114                               if (!NILP (cprop))
 18115                                 {
 18116                                   cursor = glyph;
 18117                                   break;
 18118                                 }
 18119                               if (tem && glyph->charpos < strpos)
 18120                                 {
 18121                                   strpos = glyph->charpos;
 18122                                   cursor = glyph;
 18123                                 }
 18124                             }
 18125 
 18126                           if (tem == pt_old
 18127                               || (tem - pt_old > 0 && tem < pos_after))
 18128                             goto compute_x;
 18129                         }
 18130                       if (tem)
 18131                         pos = tem + 1; /* don't find previous instances */
 18132                     }
 18133                   /* This string is not what we want; skip all of the
 18134                      glyphs that came from it.  */
 18135                   while ((row->reversed_p ? glyph > stop : glyph < stop)
 18136                          && EQ (glyph->object, str))
 18137                     glyph += incr;
 18138                 }
 18139               else
 18140                 glyph += incr;
 18141             }
 18142 
 18143           /* If we reached the end of the line, and END was from a string,
 18144              the cursor is not on this line.  */
 18145           if (cursor == NULL
 18146               && (row->reversed_p ? glyph <= end : glyph >= end)
 18147               && (row->reversed_p ? end > glyphs_end : end < glyphs_end)
 18148               && STRINGP (end->object)
 18149               && row->continued_p)
 18150             return false;
 18151         }
 18152       /* A truncated row may not include PT among its character positions.
 18153          Setting the cursor inside the scroll margin will trigger
 18154          recalculation of hscroll in hscroll_window_tree.  But if a
 18155          display string covers point, defer to the string-handling
 18156          code below to figure this out.  */
 18157       else if (row->truncated_on_left_p && pt_old < bpos_min)
 18158         {
 18159           cursor = glyph_before;
 18160           x = -1;
 18161         }
 18162       else if ((row->truncated_on_right_p && pt_old > bpos_max)
 18163                /* Zero-width characters produce no glyphs.  */
 18164                || (!empty_line_p
 18165                    && (row->reversed_p
 18166                        ? glyph_after > glyphs_end
 18167                        : glyph_after < glyphs_end)))
 18168         {
 18169           cursor = glyph_after;
 18170           x = -1;
 18171         }
 18172     }
 18173 
 18174  compute_x:
 18175   if (cursor != NULL)
 18176     glyph = cursor;
 18177   else if (glyph == glyphs_end
 18178            && pos_before == pos_after
 18179            && STRINGP ((row->reversed_p
 18180                         ? row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
 18181                         : row->glyphs[TEXT_AREA])->object))
 18182     {
 18183       /* If all the glyphs of this row came from strings, put the
 18184          cursor on the first glyph of the row.  This avoids having the
 18185          cursor outside of the text area in this very rare and hard
 18186          use case.  */
 18187       glyph =
 18188         row->reversed_p
 18189         ? row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1
 18190         : row->glyphs[TEXT_AREA];
 18191     }
 18192   if (x < 0)
 18193     {
 18194       struct glyph *g;
 18195 
 18196       /* Need to compute x that corresponds to GLYPH.  */
 18197       for (g = row->glyphs[TEXT_AREA], x = row->x; g < glyph; g++)
 18198         {
 18199           if (g >= row->glyphs[TEXT_AREA] + row->used[TEXT_AREA])
 18200             emacs_abort ();
 18201           x += g->pixel_width;
 18202         }
 18203     }
 18204 
 18205   /* ROW could be part of a continued line, which, under bidi
 18206      reordering, might have other rows whose start and end charpos
 18207      occlude point.  Only set w->cursor if we found a better
 18208      approximation to the cursor position than we have from previously
 18209      examined candidate rows belonging to the same continued line.  */
 18210   if (/* We already have a candidate row.  */
 18211       w->cursor.vpos >= 0
 18212       /* That candidate is not the row we are processing.  */
 18213       && MATRIX_ROW (matrix, w->cursor.vpos) != row
 18214       /* Make sure cursor.vpos specifies a row whose start and end
 18215          charpos occlude point, and it is valid candidate for being a
 18216          cursor-row.  This is because some callers of this function
 18217          leave cursor.vpos at the row where the cursor was displayed
 18218          during the last redisplay cycle.  */
 18219       && MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos)) <= pt_old
 18220       && pt_old <= MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
 18221       && cursor_row_p (MATRIX_ROW (matrix, w->cursor.vpos)))
 18222     {
 18223       struct glyph *g1
 18224         = MATRIX_ROW_GLYPH_START (matrix, w->cursor.vpos) + w->cursor.hpos;
 18225 
 18226       /* Don't consider glyphs that are outside TEXT_AREA.  */
 18227       if (!(row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end))
 18228         return false;
 18229       /* Keep the candidate whose buffer position is the closest to
 18230          point or has the `cursor' property.  */
 18231       if (/* Previous candidate is a glyph in TEXT_AREA of that row.  */
 18232           w->cursor.hpos >= 0
 18233           && w->cursor.hpos < MATRIX_ROW_USED (matrix, w->cursor.vpos)
 18234           && ((BUFFERP (g1->object)
 18235                && (g1->charpos == pt_old /* An exact match always wins.  */
 18236                    || (BUFFERP (glyph->object)
 18237                        && eabs (g1->charpos - pt_old)
 18238                        < eabs (glyph->charpos - pt_old))))
 18239               /* Previous candidate is a glyph from a string that has
 18240                  a non-nil `cursor' property.  */
 18241               || (STRINGP (g1->object)
 18242                   && (!NILP (Fget_char_property (make_fixnum (g1->charpos),
 18243                                                 Qcursor, g1->object))
 18244                       /* Previous candidate is from the same display
 18245                          string as this one, and the display string
 18246                          came from a text property.  */
 18247                       || (EQ (g1->object, glyph->object)
 18248                           && string_from_text_prop)
 18249                       /* this candidate is from newline and its
 18250                          position is not an exact match */
 18251                       || (NILP (glyph->object)
 18252                           && glyph->charpos != pt_old)))))
 18253         return false;
 18254       /* If this candidate gives an exact match, use that.  */
 18255       if (!((BUFFERP (glyph->object) && glyph->charpos == pt_old)
 18256             /* If this candidate is a glyph created for the
 18257                terminating newline of a line, and point is on that
 18258                newline, it wins because it's an exact match.  */
 18259             || (!row->continued_p
 18260                 && NILP (glyph->object)
 18261                 && glyph->charpos == 0
 18262                 && pt_old == MATRIX_ROW_END_CHARPOS (row) - 1))
 18263           /* Otherwise, keep the candidate that comes from a row
 18264              spanning less buffer positions.  This may win when one or
 18265              both candidate positions are on glyphs that came from
 18266              display strings, for which we cannot compare buffer
 18267              positions.  */
 18268           && MATRIX_ROW_END_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
 18269              - MATRIX_ROW_START_CHARPOS (MATRIX_ROW (matrix, w->cursor.vpos))
 18270              < MATRIX_ROW_END_CHARPOS (row) - MATRIX_ROW_START_CHARPOS (row))
 18271         return false;
 18272     }
 18273   w->cursor.hpos = glyph - row->glyphs[TEXT_AREA];
 18274   w->cursor.x = x;
 18275   w->cursor.vpos = MATRIX_ROW_VPOS (row, matrix) + dvpos;
 18276   w->cursor.y = row->y + dy;
 18277 
 18278   if (w == XWINDOW (selected_window))
 18279     {
 18280       if (!row->continued_p
 18281           && !MATRIX_ROW_CONTINUATION_LINE_P (row)
 18282           && row->x == 0)
 18283         {
 18284           this_line_buffer = XBUFFER (w->contents);
 18285 
 18286           CHARPOS (this_line_start_pos)
 18287             = MATRIX_ROW_START_CHARPOS (row) + delta;
 18288           BYTEPOS (this_line_start_pos)
 18289             = MATRIX_ROW_START_BYTEPOS (row) + delta_bytes;
 18290 
 18291           CHARPOS (this_line_end_pos)
 18292             = Z - (MATRIX_ROW_END_CHARPOS (row) + delta);
 18293           BYTEPOS (this_line_end_pos)
 18294             = Z_BYTE - (MATRIX_ROW_END_BYTEPOS (row) + delta_bytes);
 18295 
 18296           this_line_y = w->cursor.y;
 18297           this_line_pixel_height = row->height;
 18298           this_line_vpos = w->cursor.vpos;
 18299           this_line_start_x = row->x;
 18300         }
 18301       else
 18302         CHARPOS (this_line_start_pos) = 0;
 18303     }
 18304 
 18305   return true;
 18306 }
 18307 
 18308 
 18309 /* Run window scroll functions, if any, for WINDOW with new window
 18310    start STARTP.  Sets the window start of WINDOW to that position.
 18311 
 18312    We assume that the window's buffer is really current.  */
 18313 
 18314 static struct text_pos
 18315 run_window_scroll_functions (Lisp_Object window, struct text_pos startp)
 18316 {
 18317   struct window *w = XWINDOW (window);
 18318   SET_MARKER_FROM_TEXT_POS (w->start, startp);
 18319 
 18320   eassert (current_buffer == XBUFFER (w->contents));
 18321 
 18322   if (!NILP (Vwindow_scroll_functions))
 18323     {
 18324       specpdl_ref count = SPECPDL_INDEX ();
 18325       specbind (Qinhibit_quit, Qt);
 18326       safe_run_hooks_2
 18327         (Qwindow_scroll_functions, window, make_fixnum (CHARPOS (startp)));
 18328       unbind_to (count, Qnil);
 18329       SET_TEXT_POS_FROM_MARKER (startp, w->start);
 18330       /* In case the hook functions switch buffers.  */
 18331       set_buffer_internal (XBUFFER (w->contents));
 18332     }
 18333 
 18334   return startp;
 18335 }
 18336 
 18337 
 18338 /* Make sure the line containing the cursor is fully visible.
 18339    A value of true means there is nothing to be done.
 18340    (Either the line is fully visible, or it cannot be made so,
 18341    or we cannot tell.)
 18342 
 18343    If FORCE_P, return false even if partial visible cursor row
 18344    is higher than window.
 18345 
 18346    If CURRENT_MATRIX_P, use the information from the
 18347    window's current glyph matrix; otherwise use the desired glyph
 18348    matrix.
 18349 
 18350    If JUST_TEST_USER_PREFERENCE_P, just test what the value of
 18351    make-cursor-row-fully-visible requires, don't test the actual
 18352    cursor position.  The assumption is that in that case the caller
 18353    performs the necessary testing of the cursor position.
 18354 
 18355    A value of false means the caller should do scrolling
 18356    as if point had gone off the screen.  */
 18357 
 18358 static bool
 18359 cursor_row_fully_visible_p (struct window *w, bool force_p,
 18360                             bool current_matrix_p,
 18361                             bool just_test_user_preference_p)
 18362 {
 18363   struct glyph_matrix *matrix;
 18364   struct glyph_row *row;
 18365   int window_height;
 18366   Lisp_Object mclfv_p =
 18367     buffer_local_value (Qmake_cursor_line_fully_visible, w->contents);
 18368 
 18369   /* If no local binding, use the global value.  */
 18370   if (BASE_EQ (mclfv_p, Qunbound))
 18371     mclfv_p = Vmake_cursor_line_fully_visible;
 18372   /* Follow mode sets the variable to a Lisp function in buffers that
 18373      are under Follow mode.  */
 18374   if (FUNCTIONP (mclfv_p))
 18375     {
 18376       Lisp_Object window;
 18377       XSETWINDOW (window, w);
 18378       /* Implementation note: if the function we call here signals an
 18379          error, we will NOT scroll when the cursor is partially-visible.  */
 18380       Lisp_Object val = safe_call1 (mclfv_p, window);
 18381       if (NILP (val))
 18382         return true;
 18383       else if (just_test_user_preference_p)
 18384         return false;
 18385     }
 18386   else if (NILP (mclfv_p))
 18387     return true;
 18388   else if (just_test_user_preference_p)
 18389     return false;
 18390 
 18391   /* It's not always possible to find the cursor, e.g, when a window
 18392      is full of overlay strings.  Don't do anything in that case.  */
 18393   if (w->cursor.vpos < 0)
 18394     return true;
 18395 
 18396   matrix = current_matrix_p ? w->current_matrix : w->desired_matrix;
 18397   row = MATRIX_ROW (matrix, w->cursor.vpos);
 18398 
 18399   /* If the cursor row is not partially visible, there's nothing to do.  */
 18400   if (!MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row))
 18401     return true;
 18402 
 18403   /* If the row the cursor is in is taller than the window's height,
 18404      it's not clear what to do, so do nothing.  */
 18405   window_height = window_box_height (w);
 18406   if (row->height >= window_height)
 18407     {
 18408       if (!force_p || MINI_WINDOW_P (w)
 18409           || w->vscroll || w->cursor.vpos == 0)
 18410         return true;
 18411     }
 18412   return false;
 18413 }
 18414 
 18415 
 18416 /* Try scrolling PT into view in window WINDOW.  JUST_THIS_ONE_P
 18417    means only WINDOW is redisplayed in redisplay_internal.
 18418    TEMP_SCROLL_STEP has the same meaning as emacs_scroll_step, and is used
 18419    in redisplay_window to bring a partially visible line into view in
 18420    the case that only the cursor has moved.
 18421 
 18422    LAST_LINE_MISFIT should be true if we're scrolling because the
 18423    last screen line's vertical height extends past the end of the screen.
 18424 
 18425    Value is
 18426 
 18427    1    if scrolling succeeded
 18428 
 18429    0    if scrolling didn't find point.
 18430 
 18431    -1   if new fonts have been loaded so that we must interrupt
 18432    redisplay, adjust glyph matrices, and try again.  */
 18433 
 18434 enum
 18435 {
 18436   SCROLLING_SUCCESS = 1,
 18437   SCROLLING_FAILED = 0,
 18438   SCROLLING_NEED_LARGER_MATRICES = -1
 18439 };
 18440 
 18441 /* If scroll-conservatively is more than this, never recenter.
 18442 
 18443    If you change this, don't forget to update the doc string of
 18444    `scroll-conservatively' and the Emacs manual.  */
 18445 #define SCROLL_LIMIT 100
 18446 
 18447 static int
 18448 try_scrolling (Lisp_Object window, bool just_this_one_p,
 18449                intmax_t arg_scroll_conservatively, intmax_t scroll_step,
 18450                bool temp_scroll_step, bool last_line_misfit)
 18451 {
 18452   struct window *w = XWINDOW (window);
 18453   struct text_pos pos, startp;
 18454   struct it it;
 18455   int this_scroll_margin, scroll_max, rc, height;
 18456   int dy = 0, amount_to_scroll = 0;
 18457   bool scroll_down_p = false;
 18458   int extra_scroll_margin_lines = last_line_misfit;
 18459   Lisp_Object aggressive;
 18460   /* We will never try scrolling more than this number of lines.  */
 18461   int scroll_limit = SCROLL_LIMIT;
 18462   int frame_line_height = default_line_pixel_height (w);
 18463 
 18464 #ifdef GLYPH_DEBUG
 18465   debug_method_add (w, "try_scrolling");
 18466 #endif
 18467 
 18468   SET_TEXT_POS_FROM_MARKER (startp, w->start);
 18469 
 18470   this_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 18471 
 18472   /* Force arg_scroll_conservatively to have a reasonable value, to
 18473      avoid scrolling too far away with slow move_it_* functions.  Note
 18474      that the user can supply scroll-conservatively equal to
 18475      `most-positive-fixnum', which can be larger than INT_MAX.  */
 18476   if (arg_scroll_conservatively > scroll_limit)
 18477     {
 18478       arg_scroll_conservatively = scroll_limit + 1;
 18479       scroll_max = scroll_limit * frame_line_height;
 18480     }
 18481   else if (0 < scroll_step || 0 < arg_scroll_conservatively || temp_scroll_step)
 18482     /* Compute how much we should try to scroll maximally to bring
 18483        point into view.  */
 18484     {
 18485       intmax_t scroll_lines_max
 18486         = max (scroll_step, max (arg_scroll_conservatively, temp_scroll_step));
 18487       int scroll_lines = clip_to_bounds (0, scroll_lines_max, 1000000);
 18488       scroll_max = scroll_lines * frame_line_height;
 18489     }
 18490   else if (NUMBERP (BVAR (current_buffer, scroll_down_aggressively))
 18491            || NUMBERP (BVAR (current_buffer, scroll_up_aggressively)))
 18492     /* We're trying to scroll because of aggressive scrolling but no
 18493        scroll_step is set.  Choose an arbitrary one.  */
 18494     scroll_max = 10 * frame_line_height;
 18495   else
 18496     scroll_max = 0;
 18497 
 18498  too_near_end:
 18499 
 18500   /* Decide whether to scroll down.  */
 18501   if (PT > CHARPOS (startp))
 18502     {
 18503       int scroll_margin_y;
 18504 
 18505       /* Compute the pixel ypos of the scroll margin, then move IT to
 18506          either that ypos or PT, whichever comes first.  */
 18507       start_display (&it, w, startp);
 18508       scroll_margin_y = it.last_visible_y - partial_line_height (&it)
 18509         - this_scroll_margin
 18510         - frame_line_height * extra_scroll_margin_lines;
 18511       move_it_to (&it, PT, -1, scroll_margin_y - 1, -1,
 18512                   (MOVE_TO_POS | MOVE_TO_Y));
 18513 
 18514       if (PT > CHARPOS (it.current.pos))
 18515         {
 18516           int y0 = line_bottom_y (&it);
 18517           /* Compute how many pixels below window bottom to stop searching
 18518              for PT.  This avoids costly search for PT that is far away if
 18519              the user limited scrolling by a small number of lines, but
 18520              always finds PT if scroll_conservatively is set to a large
 18521              number, such as most-positive-fixnum.  */
 18522           int slack = max (scroll_max, 10 * frame_line_height);
 18523           int y_to_move = it.last_visible_y + slack;
 18524 
 18525           /* Compute the distance from the scroll margin to PT or to
 18526              the scroll limit, whichever comes first.  This should
 18527              include the height of the cursor line, to make that line
 18528              fully visible.  */
 18529           move_it_to (&it, PT, -1, y_to_move,
 18530                       -1, MOVE_TO_POS | MOVE_TO_Y);
 18531           dy = line_bottom_y (&it) - y0;
 18532 
 18533           if (dy > scroll_max)
 18534             return SCROLLING_FAILED;
 18535 
 18536           if (dy > 0)
 18537             scroll_down_p = true;
 18538         }
 18539       else if (PT == IT_CHARPOS (it)
 18540                && IT_CHARPOS (it) < ZV
 18541                && it.method == GET_FROM_STRING
 18542                && arg_scroll_conservatively > scroll_limit
 18543                && it.current_x == 0)
 18544         {
 18545           enum move_it_result skip;
 18546           int y1 = it.current_y;
 18547           int vpos;
 18548 
 18549           /* A before-string that includes newlines and is displayed
 18550              on the last visible screen line could fail us under
 18551              scroll-conservatively > 100, because we will be unable to
 18552              position the cursor on that last visible line.  Try to
 18553              recover by finding the first screen line that has some
 18554              glyphs coming from the buffer text.  */
 18555           do {
 18556             skip = move_it_in_display_line_to (&it, ZV, -1, MOVE_TO_POS);
 18557             if (skip != MOVE_NEWLINE_OR_CR
 18558                 || IT_CHARPOS (it) != PT
 18559                 || it.method == GET_FROM_BUFFER)
 18560               break;
 18561             vpos = it.vpos;
 18562             move_it_to (&it, -1, -1, -1, vpos + 1, MOVE_TO_VPOS);
 18563           } while (it.vpos > vpos);
 18564 
 18565           dy = it.current_y - y1;
 18566 
 18567           if (dy > scroll_max)
 18568             return SCROLLING_FAILED;
 18569 
 18570           if (dy > 0)
 18571             scroll_down_p = true;
 18572         }
 18573     }
 18574 
 18575   if (scroll_down_p)
 18576     {
 18577       /* Point is in or below the bottom scroll margin, so move the
 18578          window start down.  If scrolling conservatively, move it just
 18579          enough down to make point visible.  If scroll_step is set,
 18580          move it down by scroll_step.  */
 18581       if (arg_scroll_conservatively)
 18582         amount_to_scroll
 18583           = min (max (dy, frame_line_height),
 18584                  frame_line_height * arg_scroll_conservatively);
 18585       else if (scroll_step || temp_scroll_step)
 18586         amount_to_scroll = scroll_max;
 18587       else
 18588         {
 18589           aggressive = BVAR (current_buffer, scroll_up_aggressively);
 18590           height = WINDOW_BOX_TEXT_HEIGHT (w);
 18591           if (NUMBERP (aggressive))
 18592             {
 18593               double float_amount = XFLOATINT (aggressive) * height;
 18594               int aggressive_scroll = float_amount;
 18595               if (aggressive_scroll == 0 && float_amount > 0)
 18596                 aggressive_scroll = 1;
 18597               /* Don't let point enter the scroll margin near top of
 18598                  the window.  This could happen if the value of
 18599                  scroll_up_aggressively is too large and there are
 18600                  non-zero margins, because scroll_up_aggressively
 18601                  means put point that fraction of window height
 18602                  _from_the_bottom_margin_.  */
 18603               if (aggressive_scroll + 2 * this_scroll_margin > height)
 18604                 aggressive_scroll = height - 2 * this_scroll_margin;
 18605               amount_to_scroll = dy + aggressive_scroll;
 18606             }
 18607         }
 18608 
 18609       if (amount_to_scroll <= 0)
 18610         return SCROLLING_FAILED;
 18611 
 18612       start_display (&it, w, startp);
 18613       if (arg_scroll_conservatively <= scroll_limit)
 18614         move_it_vertically (&it, amount_to_scroll);
 18615       else
 18616         {
 18617           /* Extra precision for users who set scroll-conservatively
 18618              to a large number: make sure the amount we scroll
 18619              the window start is never less than amount_to_scroll,
 18620              which was computed as distance from window bottom to
 18621              point.  This matters when lines at window top and lines
 18622              below window bottom have different height.  */
 18623           struct it it1;
 18624           void *it1data = NULL;
 18625           /* We use a temporary it1 because line_bottom_y can modify
 18626              its argument, if it moves one line down; see there.  */
 18627           int start_y;
 18628 
 18629           SAVE_IT (it1, it, it1data);
 18630           start_y = line_bottom_y (&it1);
 18631           do {
 18632             RESTORE_IT (&it, &it, it1data);
 18633             move_it_by_lines (&it, 1);
 18634             SAVE_IT (it1, it, it1data);
 18635           } while (IT_CHARPOS (it) < ZV
 18636                    && line_bottom_y (&it1) - start_y < amount_to_scroll);
 18637           bidi_unshelve_cache (it1data, true);
 18638         }
 18639 
 18640       /* If STARTP is unchanged, move it down another screen line.  */
 18641       if (IT_CHARPOS (it) == CHARPOS (startp))
 18642         move_it_by_lines (&it, 1);
 18643       startp = it.current.pos;
 18644     }
 18645   else
 18646     {
 18647       struct text_pos scroll_margin_pos = startp;
 18648       int y_offset = 0;
 18649 
 18650       /* See if point is inside the scroll margin at the top of the
 18651          window.  */
 18652       if (this_scroll_margin)
 18653         {
 18654           int y_start;
 18655 
 18656           start_display (&it, w, startp);
 18657           y_start = it.current_y;
 18658           move_it_vertically (&it, this_scroll_margin);
 18659           scroll_margin_pos = it.current.pos;
 18660           /* If we didn't move enough before hitting ZV, request
 18661              additional amount of scroll, to move point out of the
 18662              scroll margin.  */
 18663           if (IT_CHARPOS (it) == ZV
 18664               && it.current_y - y_start < this_scroll_margin)
 18665             y_offset = this_scroll_margin - (it.current_y - y_start);
 18666         }
 18667 
 18668       if (PT < CHARPOS (scroll_margin_pos))
 18669         {
 18670           /* Point is in the scroll margin at the top of the window or
 18671              above what is displayed in the window.  */
 18672           int y0, y_to_move;
 18673 
 18674           /* Compute the vertical distance from PT to the scroll
 18675              margin position.  Move as far as scroll_max allows, or
 18676              one screenful, or 10 screen lines, whichever is largest.
 18677              Give up if distance is greater than scroll_max or if we
 18678              didn't reach the scroll margin position.  */
 18679           SET_TEXT_POS (pos, PT, PT_BYTE);
 18680           start_display (&it, w, pos);
 18681           y0 = it.current_y;
 18682           y_to_move = max (it.last_visible_y,
 18683                            max (scroll_max, 10 * frame_line_height));
 18684           move_it_to (&it, CHARPOS (scroll_margin_pos), 0,
 18685                       y_to_move, -1,
 18686                       MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 18687           dy = it.current_y - y0;
 18688           if (dy > scroll_max
 18689               || IT_CHARPOS (it) < CHARPOS (scroll_margin_pos))
 18690             return SCROLLING_FAILED;
 18691 
 18692           /* Additional scroll for when ZV was too close to point.  */
 18693           dy += y_offset;
 18694 
 18695           /* Compute new window start.  */
 18696           start_display (&it, w, startp);
 18697 
 18698           if (arg_scroll_conservatively)
 18699             amount_to_scroll
 18700               = min (max (dy, frame_line_height),
 18701                      frame_line_height * arg_scroll_conservatively);
 18702           else if (scroll_step || temp_scroll_step)
 18703             amount_to_scroll = scroll_max;
 18704           else
 18705             {
 18706               aggressive = BVAR (current_buffer, scroll_down_aggressively);
 18707               height = WINDOW_BOX_TEXT_HEIGHT (w);
 18708               if (NUMBERP (aggressive))
 18709                 {
 18710                   double float_amount = XFLOATINT (aggressive) * height;
 18711                   int aggressive_scroll = float_amount;
 18712                   if (aggressive_scroll == 0 && float_amount > 0)
 18713                     aggressive_scroll = 1;
 18714                   /* Don't let point enter the scroll margin near
 18715                      bottom of the window, if the value of
 18716                      scroll_down_aggressively happens to be too
 18717                      large.  */
 18718                   if (aggressive_scroll + 2 * this_scroll_margin > height)
 18719                     aggressive_scroll = height - 2 * this_scroll_margin;
 18720                   amount_to_scroll = dy + aggressive_scroll;
 18721                 }
 18722             }
 18723 
 18724           if (amount_to_scroll <= 0)
 18725             return SCROLLING_FAILED;
 18726 
 18727           move_it_vertically_backward (&it, amount_to_scroll);
 18728           startp = it.current.pos;
 18729         }
 18730     }
 18731 
 18732   /* Run window scroll functions.  */
 18733   startp = run_window_scroll_functions (window, startp);
 18734 
 18735   /* Display the window.  Give up if new fonts are loaded, or if point
 18736      doesn't appear.  */
 18737   if (!try_window (window, startp, 0))
 18738     rc = SCROLLING_NEED_LARGER_MATRICES;
 18739   else if (w->cursor.vpos < 0)
 18740     {
 18741       clear_glyph_matrix (w->desired_matrix);
 18742       rc = SCROLLING_FAILED;
 18743     }
 18744   else
 18745     {
 18746       /* Maybe forget recorded base line for line number display.  */
 18747       if (!just_this_one_p
 18748           || current_buffer->clip_changed
 18749           || BEG_UNCHANGED < CHARPOS (startp))
 18750         w->base_line_number = 0;
 18751 
 18752       /* If cursor ends up on a partially visible line,
 18753          treat that as being off the bottom of the screen.  */
 18754       if (! cursor_row_fully_visible_p (w, extra_scroll_margin_lines <= 1,
 18755                                         false, false)
 18756           /* It's possible that the cursor is on the first line of the
 18757              buffer, which is partially obscured due to a vscroll
 18758              (Bug#7537).  In that case, avoid looping forever. */
 18759           && extra_scroll_margin_lines < w->desired_matrix->nrows - 1)
 18760         {
 18761           clear_glyph_matrix (w->desired_matrix);
 18762           ++extra_scroll_margin_lines;
 18763           goto too_near_end;
 18764         }
 18765       rc = SCROLLING_SUCCESS;
 18766     }
 18767 
 18768   return rc;
 18769 }
 18770 
 18771 
 18772 /* Compute a suitable window start for window W if display of W starts
 18773    on a continuation line.  Value is true if a new window start
 18774    was computed.
 18775 
 18776    The new window start will be computed, based on W's width, starting
 18777    from the start of the continued line.  It is the start of the
 18778    screen line with the minimum distance from the old start W->start,
 18779    which is still before point (otherwise point will definitely not
 18780    be visible in the window).  */
 18781 
 18782 static bool
 18783 compute_window_start_on_continuation_line (struct window *w)
 18784 {
 18785   struct text_pos pos, start_pos, pos_before_pt;
 18786   bool window_start_changed_p = false;
 18787 
 18788   SET_TEXT_POS_FROM_MARKER (start_pos, w->start);
 18789 
 18790   /* If window start is on a continuation line...  Window start may be
 18791      < BEGV in case there's invisible text at the start of the
 18792      buffer (M-x rmail, for example).  */
 18793   if (CHARPOS (start_pos) > BEGV
 18794       && FETCH_BYTE (BYTEPOS (start_pos) - 1) != '\n')
 18795     {
 18796       struct it it;
 18797       struct glyph_row *row;
 18798 
 18799       /* Handle the case that the window start is out of range.  */
 18800       if (CHARPOS (start_pos) < BEGV)
 18801         SET_TEXT_POS (start_pos, BEGV, BEGV_BYTE);
 18802       else if (CHARPOS (start_pos) > ZV)
 18803         SET_TEXT_POS (start_pos, ZV, ZV_BYTE);
 18804 
 18805       /* Find the start of the continued line.  This should be fast
 18806          because find_newline is fast (newline cache).  */
 18807       row = w->desired_matrix->rows + window_wants_tab_line (w)
 18808                                     + window_wants_header_line (w);
 18809       init_iterator (&it, w, CHARPOS (start_pos), BYTEPOS (start_pos),
 18810                      row, DEFAULT_FACE_ID);
 18811       reseat_at_previous_visible_line_start (&it);
 18812 
 18813       /* Give up (by not using the code in the block below) and say it
 18814          takes too much time to compute a new window start, if the
 18815          line start is "too far" away from the window start.  Also,
 18816          give up if the line start is after point, as in that case
 18817          point will not be visible with any window start we
 18818          compute.  */
 18819       if (IT_CHARPOS (it) <= PT
 18820           && (CHARPOS (start_pos) - IT_CHARPOS (it)
 18821               /* PXW: Do we need upper bounds here?  */
 18822               < WINDOW_TOTAL_LINES (w) * WINDOW_TOTAL_COLS (w)))
 18823         {
 18824           int min_distance, distance;
 18825 
 18826           /* Move forward by display lines to find the new window
 18827              start.  If window width was enlarged, the new start can
 18828              be expected to be > the old start.  If window width was
 18829              decreased, the new window start will be < the old start.
 18830              So, we're looking for the display line start with the
 18831              minimum distance from the old window start.  */
 18832           pos_before_pt = pos = it.current.pos;
 18833           min_distance = DISP_INFINITY;
 18834           while ((distance = eabs (CHARPOS (start_pos) - IT_CHARPOS (it))),
 18835                  distance < min_distance)
 18836             {
 18837               min_distance = distance;
 18838               if (CHARPOS (pos) <= PT)
 18839                 pos_before_pt = pos;
 18840               pos = it.current.pos;
 18841               if (it.line_wrap == WORD_WRAP)
 18842                 {
 18843                   /* Under WORD_WRAP, move_it_by_lines is likely to
 18844                      overshoot and stop not at the first, but the
 18845                      second character from the left margin.  So in
 18846                      that case, we need a more tight control on the X
 18847                      coordinate of the iterator than move_it_by_lines
 18848                      promises in its contract.  The method is to first
 18849                      go to the last (rightmost) visible character of a
 18850                      line, then move to the leftmost character on the
 18851                      next line in a separate call.  */
 18852                   move_it_to (&it, ZV, it.last_visible_x, it.current_y, -1,
 18853                               MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 18854                   move_it_to (&it, ZV, 0,
 18855                               it.current_y + it.max_ascent + it.max_descent, -1,
 18856                               MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 18857                 }
 18858               else
 18859                 move_it_by_lines (&it, 1);
 18860             }
 18861 
 18862           /* It makes very little sense to make the new window start
 18863              after point, as point won't be visible.  If that's what
 18864              the loop above finds, fall back on the candidate before
 18865              or at point that is closest to the old window start.  */
 18866           if (CHARPOS (pos) > PT)
 18867             pos = pos_before_pt;
 18868 
 18869           /* Set the window start there.  */
 18870           SET_MARKER_FROM_TEXT_POS (w->start, pos);
 18871           window_start_changed_p = true;
 18872         }
 18873     }
 18874 
 18875   return window_start_changed_p;
 18876 }
 18877 
 18878 
 18879 /* Try cursor movement in case text has not changed in window WINDOW,
 18880    with window start STARTP.  Value is
 18881 
 18882    CURSOR_MOVEMENT_SUCCESS if successful
 18883 
 18884    CURSOR_MOVEMENT_CANNOT_BE_USED if this method cannot be used
 18885 
 18886    CURSOR_MOVEMENT_MUST_SCROLL if we know we have to scroll the
 18887    display.  *SCROLL_STEP is set to true, under certain circumstances, if
 18888    we want to scroll as if scroll-step were set to 1.  See the code.
 18889 
 18890    CURSOR_MOVEMENT_NEED_LARGER_MATRICES if we need larger matrices, in
 18891    which case we have to abort this redisplay, and adjust matrices
 18892    first.  */
 18893 
 18894 enum
 18895 {
 18896   CURSOR_MOVEMENT_SUCCESS,
 18897   CURSOR_MOVEMENT_CANNOT_BE_USED,
 18898   CURSOR_MOVEMENT_MUST_SCROLL,
 18899   CURSOR_MOVEMENT_NEED_LARGER_MATRICES
 18900 };
 18901 
 18902 static int
 18903 try_cursor_movement (Lisp_Object window, struct text_pos startp,
 18904                      bool *scroll_step)
 18905 {
 18906   struct window *w = XWINDOW (window);
 18907   struct frame *f = XFRAME (w->frame);
 18908   int rc = CURSOR_MOVEMENT_CANNOT_BE_USED;
 18909 
 18910 #ifdef GLYPH_DEBUG
 18911   if (inhibit_try_cursor_movement)
 18912     return rc;
 18913 #endif
 18914 
 18915   /* Previously, there was a check for Lisp integer in the
 18916      if-statement below. Now, this field is converted to
 18917      ptrdiff_t, thus zero means invalid position in a buffer.  */
 18918   eassert (w->last_point > 0);
 18919   /* Likewise there was a check whether window_end_vpos is nil or larger
 18920      than the window.  Now window_end_vpos is int and so never nil, but
 18921      let's leave eassert to check whether it fits in the window.  */
 18922   eassert (!w->window_end_valid
 18923            || w->window_end_vpos < w->current_matrix->nrows);
 18924 
 18925   /* Handle case where text has not changed, only point, and it has
 18926      not moved off the frame.  */
 18927   if (/* Point may be in this window.  */
 18928       PT >= CHARPOS (startp)
 18929       /* Selective display hasn't changed.  */
 18930       && !current_buffer->clip_changed
 18931       /* Function force-mode-line-update is used to force a thorough
 18932          redisplay.  It sets either windows_or_buffers_changed or
 18933          update_mode_lines.  So don't take a shortcut here for these
 18934          cases.  */
 18935       && !update_mode_lines
 18936       && !windows_or_buffers_changed
 18937       && !f->cursor_type_changed
 18938       && NILP (Vshow_trailing_whitespace)
 18939       /* When display-line-numbers is in relative mode, moving point
 18940          requires to redraw the entire window.  */
 18941       && !EQ (Vdisplay_line_numbers, Qrelative)
 18942       && !EQ (Vdisplay_line_numbers, Qvisual)
 18943       /* When the current line number should be displayed in a
 18944          distinct face, moving point cannot be handled in optimized
 18945          way as below.  */
 18946       && !(!NILP (Vdisplay_line_numbers)
 18947            && NILP (Finternal_lisp_face_equal_p (Qline_number,
 18948                                                  Qline_number_current_line,
 18949                                                  w->frame)))
 18950       /* This code is not used for mini-buffer for the sake of the case
 18951          of redisplaying to replace an echo area message; since in
 18952          that case the mini-buffer contents per se are usually
 18953          unchanged.  This code is of no real use in the mini-buffer
 18954          since the handling of this_line_start_pos, etc., in redisplay
 18955          handles the same cases.  */
 18956       && !EQ (window, minibuf_window)
 18957       /* When overlay arrow is shown in current buffer, point movement
 18958          is no longer "simple", as it typically causes the overlay
 18959          arrow to move as well.  */
 18960       && !overlay_arrow_in_current_buffer_p ())
 18961     {
 18962       int this_scroll_margin, top_scroll_margin;
 18963       struct glyph_row *row = NULL;
 18964 
 18965 #ifdef GLYPH_DEBUG
 18966       debug_method_add (w, "cursor movement");
 18967 #endif
 18968 
 18969       this_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 18970 
 18971       top_scroll_margin = this_scroll_margin;
 18972       if (window_wants_tab_line (w))
 18973         top_scroll_margin += CURRENT_TAB_LINE_HEIGHT (w);
 18974       if (window_wants_header_line (w))
 18975         top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
 18976 
 18977       /* Start with the row the cursor was displayed during the last
 18978          not paused redisplay.  Give up if that row is not valid.  */
 18979       if (w->last_cursor_vpos < 0
 18980           || w->last_cursor_vpos >= w->current_matrix->nrows)
 18981         rc = CURSOR_MOVEMENT_MUST_SCROLL;
 18982       else
 18983         {
 18984           row = MATRIX_ROW (w->current_matrix, w->last_cursor_vpos);
 18985           /* Skip the tab-line and header-line rows, if any.  */
 18986           if (row->tab_line_p)
 18987             ++row;
 18988           if (row->mode_line_p)
 18989             ++row;
 18990           if (!row->enabled_p)
 18991             rc = CURSOR_MOVEMENT_MUST_SCROLL;
 18992         }
 18993 
 18994       if (rc == CURSOR_MOVEMENT_CANNOT_BE_USED)
 18995         {
 18996           bool scroll_p = false, must_scroll = false;
 18997           int last_y = window_text_bottom_y (w) - this_scroll_margin;
 18998 
 18999           if (PT > w->last_point)
 19000             {
 19001               /* Point has moved forward.  */
 19002               while (MATRIX_ROW_END_CHARPOS (row) < PT
 19003                      && MATRIX_ROW_BOTTOM_Y (row) < last_y)
 19004                 {
 19005                   eassert (row->enabled_p);
 19006                   ++row;
 19007                 }
 19008 
 19009               /* If the end position of a row equals the start
 19010                  position of the next row, and PT is at that position,
 19011                  we would rather display cursor in the next line.  */
 19012               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
 19013                      && MATRIX_ROW_END_CHARPOS (row) == PT
 19014                      && row < MATRIX_MODE_LINE_ROW (w->current_matrix)
 19015                      && MATRIX_ROW_START_CHARPOS (row+1) >= PT
 19016                      && !cursor_row_p (row))
 19017                 ++row;
 19018 
 19019               /* If within the scroll margin, scroll.  Note that
 19020                  MATRIX_ROW_BOTTOM_Y gives the pixel position at which
 19021                  the next line would be drawn, and that
 19022                  this_scroll_margin can be zero.  */
 19023               if (MATRIX_ROW_BOTTOM_Y (row) > last_y
 19024                   || PT > MATRIX_ROW_END_CHARPOS (row)
 19025                   /* Line is completely visible last line in window
 19026                      and PT is to be set in the next line.  */
 19027                   || (MATRIX_ROW_BOTTOM_Y (row) == last_y
 19028                       && PT == MATRIX_ROW_END_CHARPOS (row)
 19029                       && !row->ends_at_zv_p
 19030                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
 19031                 scroll_p = true;
 19032             }
 19033           else if (PT < w->last_point)
 19034             {
 19035               /* Cursor has to be moved backward.  Note that PT >=
 19036                  CHARPOS (startp) because of the outer if-statement.  */
 19037               struct glyph_row *row0 = row;
 19038 
 19039               while (!row->mode_line_p
 19040                      && (MATRIX_ROW_START_CHARPOS (row) > PT
 19041                          || (MATRIX_ROW_START_CHARPOS (row) == PT
 19042                              && (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P (row)
 19043                                  || (/* STARTS_IN_MIDDLE_OF_STRING_P (row) */
 19044                                      row > w->current_matrix->rows
 19045                                      && (row-1)->ends_in_newline_from_string_p))))
 19046                      && (row->y > top_scroll_margin
 19047                          || CHARPOS (startp) == BEGV))
 19048                 {
 19049                   eassert (row->enabled_p);
 19050                   --row;
 19051                 }
 19052 
 19053               /* With bidi-reordered rows we can have buffer positions
 19054                  _decrease_ when going down by rows.  If we haven't
 19055                  found our row in the loop above, give it another try
 19056                  now going in the other direction from the original row.  */
 19057               if (!(MATRIX_ROW_START_CHARPOS (row) <= PT
 19058                     && PT <= MATRIX_ROW_END_CHARPOS (row))
 19059                   && row0->continued_p)
 19060                 {
 19061                   row = row0;
 19062                   while (MATRIX_ROW_START_CHARPOS (row) > PT
 19063                          && MATRIX_ROW_BOTTOM_Y (row) < last_y)
 19064                     {
 19065                       eassert (row->enabled_p);
 19066                       ++row;
 19067                     }
 19068                 }
 19069 
 19070               /* Consider the following case: Window starts at BEGV,
 19071                  there is invisible, intangible text at BEGV, so that
 19072                  display starts at some point START > BEGV.  It can
 19073                  happen that we are called with PT somewhere between
 19074                  BEGV and START.  Try to handle that case.  */
 19075               if (row < w->current_matrix->rows
 19076                   || row->mode_line_p)
 19077                 {
 19078                   row = w->current_matrix->rows;
 19079                   /* Skip the tab-line and header-line rows, if any.  */
 19080                   if (row->tab_line_p)
 19081                     ++row;
 19082                   if (row->mode_line_p)
 19083                     ++row;
 19084                 }
 19085 
 19086               /* Due to newlines in overlay strings, we may have to
 19087                  skip forward over overlay strings.  */
 19088               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
 19089                      && MATRIX_ROW_END_CHARPOS (row) == PT
 19090                      && !cursor_row_p (row))
 19091                 ++row;
 19092 
 19093               /* If within the scroll margin, either the top one or
 19094                  the bottom one, scroll.  */
 19095               if ((row->y < top_scroll_margin
 19096                    && CHARPOS (startp) != BEGV)
 19097                   || MATRIX_ROW_BOTTOM_Y (row) > last_y
 19098                   || PT > MATRIX_ROW_END_CHARPOS (row)
 19099                   || (MATRIX_ROW_BOTTOM_Y (row) == last_y
 19100                       && PT == MATRIX_ROW_END_CHARPOS (row)
 19101                       && !row->ends_at_zv_p
 19102                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
 19103                 scroll_p = true;
 19104             }
 19105           else
 19106             {
 19107               /* Cursor did not move.  So don't scroll even if cursor line
 19108                  is partially visible, as it was so before.  */
 19109                  rc = CURSOR_MOVEMENT_SUCCESS;
 19110             }
 19111 
 19112           if ((PT < MATRIX_ROW_START_CHARPOS (row)
 19113                && (row == MATRIX_FIRST_TEXT_ROW (w->current_matrix)
 19114                    /* Don't give up if point is inside invisible text
 19115                       at the beginning of its glyph row.  */
 19116                    || (MATRIX_ROW_END_CHARPOS (row-1)
 19117                        == MATRIX_ROW_START_CHARPOS (row))))
 19118               || PT > MATRIX_ROW_END_CHARPOS (row))
 19119             {
 19120               /* if PT is not in the glyph row, give up.  */
 19121               rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19122               must_scroll = true;
 19123             }
 19124           else if (rc != CURSOR_MOVEMENT_SUCCESS
 19125                    && !NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
 19126             {
 19127               struct glyph_row *row1;
 19128 
 19129               /* If rows are bidi-reordered and point moved, back up
 19130                  until we find a row that does not belong to a
 19131                  continuation line.  This is because we must consider
 19132                  all rows of a continued line as candidates for the
 19133                  new cursor positioning, since row start and end
 19134                  positions change non-linearly with vertical position
 19135                  in such rows.  */
 19136               /* FIXME: Revisit this when glyph ``spilling'' in
 19137                  continuation lines' rows is implemented for
 19138                  bidi-reordered rows.  */
 19139               for (row1 = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 19140                    MATRIX_ROW_CONTINUATION_LINE_P (row);
 19141                    --row)
 19142                 {
 19143                   /* If we hit the beginning of the displayed portion
 19144                      without finding the first row of a continued
 19145                      line, give up.  */
 19146                   if (row <= row1)
 19147                     {
 19148                       rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19149                       break;
 19150                     }
 19151                   eassert (row->enabled_p);
 19152                 }
 19153             }
 19154           if (must_scroll)
 19155             ;
 19156           else if (rc != CURSOR_MOVEMENT_SUCCESS
 19157               && MATRIX_ROW_PARTIALLY_VISIBLE_P (w, row)
 19158               /* Make sure this isn't a header line nor a tab-line by
 19159                  any chance, since then MATRIX_ROW_PARTIALLY_VISIBLE_P
 19160                  might yield true.  */
 19161               && !row->mode_line_p
 19162               && !cursor_row_fully_visible_p (w, true, true, true))
 19163             {
 19164               if (PT == MATRIX_ROW_END_CHARPOS (row)
 19165                   && !row->ends_at_zv_p
 19166                   && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
 19167                 rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19168               else if (row->height > window_box_height (w))
 19169                 {
 19170                   /* If we end up in a partially visible line, let's
 19171                      make it fully visible, except when it's taller
 19172                      than the window, in which case we can't do much
 19173                      about it.  */
 19174                   *scroll_step = true;
 19175                   rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19176                 }
 19177               else
 19178                 {
 19179                   set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
 19180                   if (!cursor_row_fully_visible_p (w, false, true, false))
 19181                     rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19182                   else
 19183                     rc = CURSOR_MOVEMENT_SUCCESS;
 19184                 }
 19185             }
 19186           else if (scroll_p)
 19187             rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19188           else if (rc != CURSOR_MOVEMENT_SUCCESS
 19189                    && !NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
 19190             {
 19191               /* With bidi-reordered rows, there could be more than
 19192                  one candidate row whose start and end positions
 19193                  occlude point.  We need to let set_cursor_from_row
 19194                  find the best candidate.  */
 19195               /* FIXME: Revisit this when glyph ``spilling'' in
 19196                  continuation lines' rows is implemented for
 19197                  bidi-reordered rows.  */
 19198               bool rv = false;
 19199               bool pt_invis = false;
 19200               Lisp_Object val = get_char_property_and_overlay (make_fixnum (PT),
 19201                                                                Qinvisible,
 19202                                                                Qnil, NULL);
 19203 
 19204               if (TEXT_PROP_MEANS_INVISIBLE (val) != 0)
 19205                 pt_invis = true;
 19206 
 19207               do
 19208                 {
 19209                   bool at_zv_p = false, exact_match_p = false;
 19210 
 19211                   /* If point is in invisible text, we cannot assume
 19212                      it must be after row's start position, since the
 19213                      row could have invisible text at its beginning
 19214                      where point is located.  */
 19215                   if ((pt_invis || MATRIX_ROW_START_CHARPOS (row) <= PT)
 19216                       && PT <= MATRIX_ROW_END_CHARPOS (row)
 19217                       && cursor_row_p (row))
 19218                     rv |= set_cursor_from_row (w, row, w->current_matrix,
 19219                                                0, 0, 0, 0);
 19220                   /* As soon as we've found the exact match for point,
 19221                      or the first suitable row whose ends_at_zv_p flag
 19222                      is set, we are done.  */
 19223                   if (rv)
 19224                     {
 19225                       at_zv_p = MATRIX_ROW (w->current_matrix,
 19226                                             w->cursor.vpos)->ends_at_zv_p;
 19227                       if (!at_zv_p
 19228                           && w->cursor.hpos >= 0
 19229                           && w->cursor.hpos < MATRIX_ROW_USED (w->current_matrix,
 19230                                                                w->cursor.vpos))
 19231                         {
 19232                           struct glyph_row *candidate =
 19233                             MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 19234                           struct glyph *g =
 19235                             candidate->glyphs[TEXT_AREA] + w->cursor.hpos;
 19236                           ptrdiff_t endpos = MATRIX_ROW_END_CHARPOS (candidate);
 19237 
 19238                           exact_match_p =
 19239                             (BUFFERP (g->object) && g->charpos == PT)
 19240                             || (NILP (g->object)
 19241                                 && (g->charpos == PT
 19242                                     || (g->charpos == 0 && endpos - 1 == PT)));
 19243                           /* Perhaps the point position is inside
 19244                              invisible text?  In that case, we trust
 19245                              'set_cursor_from_row' to do its job and
 19246                              find the best position for the cursor.  */
 19247                           if (!exact_match_p && pt_invis)
 19248                             exact_match_p = true;
 19249                         }
 19250                       if (at_zv_p || exact_match_p)
 19251                         {
 19252                           rc = CURSOR_MOVEMENT_SUCCESS;
 19253                           break;
 19254                         }
 19255                     }
 19256                   if (MATRIX_ROW_BOTTOM_Y (row) == last_y)
 19257                     break;
 19258                   ++row;
 19259                 }
 19260               while (((MATRIX_ROW_CONTINUATION_LINE_P (row)
 19261                        || row->continued_p)
 19262                       && MATRIX_ROW_BOTTOM_Y (row) <= last_y)
 19263                      || (MATRIX_ROW_START_CHARPOS (row) == PT
 19264                          && MATRIX_ROW_BOTTOM_Y (row) < last_y));
 19265               /* If we didn't find any candidate rows, or exited the
 19266                  loop before all the candidates were examined, signal
 19267                  to the caller that this method failed.  */
 19268               if (rc != CURSOR_MOVEMENT_SUCCESS
 19269                   && !(rv
 19270                        && !MATRIX_ROW_CONTINUATION_LINE_P (row)
 19271                        && !row->continued_p))
 19272                 rc = CURSOR_MOVEMENT_MUST_SCROLL;
 19273               else if (rv)
 19274                 rc = CURSOR_MOVEMENT_SUCCESS;
 19275             }
 19276           else
 19277             {
 19278               do
 19279                 {
 19280                   if (set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0))
 19281                     {
 19282                       rc = CURSOR_MOVEMENT_SUCCESS;
 19283                       break;
 19284                     }
 19285                   ++row;
 19286                 }
 19287               while (MATRIX_ROW_BOTTOM_Y (row) < last_y
 19288                      && MATRIX_ROW_START_CHARPOS (row) == PT
 19289                      && cursor_row_p (row));
 19290             }
 19291         }
 19292     }
 19293 
 19294   return rc;
 19295 }
 19296 
 19297 
 19298 void
 19299 set_vertical_scroll_bar (struct window *w)
 19300 {
 19301   ptrdiff_t start, end, whole;
 19302 
 19303   /* Calculate the start and end positions for the current window.
 19304      At some point, it would be nice to choose between scrollbars
 19305      which reflect the whole buffer size, with special markers
 19306      indicating narrowing, and scrollbars which reflect only the
 19307      visible region.
 19308 
 19309      Note that mini-buffers sometimes aren't displaying any text.  */
 19310   if (!MINI_WINDOW_P (w)
 19311       || (w == XWINDOW (minibuf_window)
 19312           && NILP (echo_area_buffer[0])))
 19313     {
 19314       struct buffer *buf = XBUFFER (w->contents);
 19315 
 19316       whole = BUF_ZV (buf) - BUF_BEGV (buf);
 19317       start = marker_position (w->start) - BUF_BEGV (buf);
 19318       end = BUF_Z (buf) - w->window_end_pos - BUF_BEGV (buf);
 19319 
 19320       /* If w->window_end_pos cannot be trusted, recompute it "the
 19321          hard way".  But don't bother to be too accurate when
 19322          long-line shortcuts are in effect.  */
 19323       if (!w->window_end_valid && !buf->long_line_optimizations_p)
 19324         {
 19325           struct it it;
 19326           struct text_pos start_pos;
 19327           struct buffer *obuf = current_buffer;
 19328           /* When we display the scroll bar of a mini-window,
 19329              current_buffer is not guaranteed to be the mini-window's
 19330              buffer, see the beginning of redisplay_window.  */
 19331           set_buffer_internal_1 (XBUFFER (w->contents));
 19332           SET_TEXT_POS_FROM_MARKER (start_pos, w->start);
 19333           start_display (&it, w, start_pos);
 19334           move_it_to (&it, -1, it.last_visible_x, window_box_height (w), -1,
 19335                       MOVE_TO_X | MOVE_TO_Y);
 19336           end -= (BUF_Z (buf) - IT_CHARPOS (it)) - w->window_end_pos;
 19337           set_buffer_internal_1 (obuf);
 19338         }
 19339 
 19340       if (end < start)
 19341         end = start;
 19342       if (whole < (end - start))
 19343         whole = end - start;
 19344     }
 19345   else
 19346     start = end = whole = 0;
 19347 
 19348   /* Indicate what this scroll bar ought to be displaying now.  */
 19349   if (FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
 19350     (*FRAME_TERMINAL (XFRAME (w->frame))->set_vertical_scroll_bar_hook)
 19351       (w, end - start, whole, start);
 19352 }
 19353 
 19354 
 19355 void
 19356 set_horizontal_scroll_bar (struct window *w)
 19357 {
 19358   int start, end, whole, portion;
 19359 
 19360   if (!MINI_WINDOW_P (w) || EQ (w->horizontal_scroll_bar_type, Qbottom))
 19361     {
 19362       struct buffer *b = XBUFFER (w->contents);
 19363       struct buffer *old_buffer = NULL;
 19364       struct it it;
 19365       struct text_pos startp;
 19366 
 19367       if (b != current_buffer)
 19368         {
 19369           old_buffer = current_buffer;
 19370           set_buffer_internal (b);
 19371         }
 19372 
 19373       SET_TEXT_POS_FROM_MARKER (startp, w->start);
 19374       start_display (&it, w, startp);
 19375       it.last_visible_x = INT_MAX;
 19376       whole = move_it_to (&it, -1, INT_MAX, window_box_height (w), -1,
 19377                           MOVE_TO_X | MOVE_TO_Y);
 19378       /* whole = move_it_to (&it, w->window_end_pos, INT_MAX,
 19379                           window_box_height (w), -1,
 19380                           MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y); */
 19381 
 19382       start = w->hscroll * FRAME_COLUMN_WIDTH (WINDOW_XFRAME (w));
 19383       end = start + window_box_width (w, TEXT_AREA);
 19384       portion = end - start;
 19385       /* After enlarging a horizontally scrolled window such that it
 19386          gets at least as wide as the text it contains, make sure that
 19387          the thumb doesn't fill the entire scroll bar so we can still
 19388          drag it back to see the entire text.  */
 19389       whole = max (whole, end);
 19390 
 19391       if (it.bidi_p)
 19392         {
 19393           Lisp_Object pdir;
 19394 
 19395           pdir = Fcurrent_bidi_paragraph_direction (Qnil);
 19396           if (EQ (pdir, Qright_to_left))
 19397             {
 19398               start = whole - end;
 19399               end = start + portion;
 19400             }
 19401         }
 19402 
 19403       if (old_buffer)
 19404         set_buffer_internal (old_buffer);
 19405     }
 19406   else
 19407     start = end = whole = portion = 0;
 19408 
 19409   w->hscroll_whole = whole;
 19410 
 19411   /* Indicate what this scroll bar ought to be displaying now.  */
 19412   if (FRAME_TERMINAL (XFRAME (w->frame))->set_horizontal_scroll_bar_hook)
 19413     (*FRAME_TERMINAL (XFRAME (w->frame))->set_horizontal_scroll_bar_hook)
 19414       (w, portion, whole, start);
 19415 }
 19416 
 19417 /* Subroutine of redisplay_window, to determine whether a window-start
 19418    point STARTP of WINDOW should be rejected.  */
 19419 static bool
 19420 window_start_acceptable_p (Lisp_Object window, ptrdiff_t startp)
 19421 {
 19422   if (!make_window_start_visible)
 19423     return true;
 19424 
 19425   struct window *w = XWINDOW (window);
 19426   struct frame *f = XFRAME (w->frame);
 19427   Lisp_Object startpos = make_fixnum (startp);
 19428   Lisp_Object invprop, disp_spec;
 19429   struct text_pos ignored;
 19430 
 19431   /* Is STARTP in invisible text?  */
 19432   if ((invprop = Fget_char_property (startpos, Qinvisible, window)),
 19433       TEXT_PROP_MEANS_INVISIBLE (invprop) != 0)
 19434     return false;
 19435 
 19436   /* Is STARTP covered by a replacing 'display' property?  */
 19437   if (!NILP (disp_spec = Fget_char_property (startpos, Qdisplay, window))
 19438       && handle_display_spec (NULL, disp_spec, Qnil, Qnil, &ignored, startp,
 19439                               FRAME_WINDOW_P (f)) > 0)
 19440     return false;
 19441 
 19442   return true;
 19443 }
 19444 
 19445 DEFUN ("long-line-optimizations-p", Flong_line_optimizations_p, Slong_line_optimizations_p,
 19446        0, 0, 0,
 19447        doc: /* Return non-nil if long-line optimizations are in effect in current buffer.
 19448 See `long-line-threshold' and `large-hscroll-threshold' for what these
 19449 optimizations mean and when they are in effect.  */)
 19450   (void)
 19451 {
 19452   return current_buffer->long_line_optimizations_p ? Qt : Qnil;
 19453 }
 19454 
 19455 /* Redisplay leaf window WINDOW.  JUST_THIS_ONE_P means only
 19456    selected_window is redisplayed.
 19457 
 19458    We can return without actually redisplaying the window if fonts has been
 19459    changed on window's frame.  In that case, redisplay_internal will retry.
 19460 
 19461    As one of the important parts of redisplaying a window, we need to
 19462    decide whether the previous window-start position (stored in the
 19463    window's w->start marker position) is still valid, and if it isn't,
 19464    recompute it.  Some details about that:
 19465 
 19466     . The previous window-start could be in a continuation line, in
 19467       which case we need to recompute it when the window width
 19468       changes.  See compute_window_start_on_continuation_line and its
 19469       call below.
 19470 
 19471     . The text that changed since last redisplay could include the
 19472       previous window-start position.  In that case, we try to salvage
 19473       what we can from the current glyph matrix by calling
 19474       try_scrolling, which see.
 19475 
 19476     . Some Emacs command could force us to use a specific window-start
 19477       position by setting the window's force_start flag, or gently
 19478       propose doing that by setting the window's optional_new_start
 19479       flag.  In these cases, we try using the specified start point if
 19480       that succeeds (i.e. the window desired matrix is successfully
 19481       recomputed, and point location is within the window).  In case
 19482       of optional_new_start, we first check if the specified start
 19483       position is feasible, i.e. if it will allow point to be
 19484       displayed in the window.  If using the specified start point
 19485       fails, e.g., if new fonts are needed to be loaded, we abort the
 19486       redisplay cycle and leave it up to the next cycle to figure out
 19487       things.
 19488 
 19489     . Note that the window's force_start flag is sometimes set by
 19490       redisplay itself, when it decides that the previous window start
 19491       point is fine and should be kept.  Search for "goto force_start"
 19492       below to see the details.  Like the values of window-start
 19493       specified outside of redisplay, these internally-deduced values
 19494       are tested for feasibility, and ignored if found to be
 19495       unfeasible.
 19496 
 19497     . Note that the function try_window, used to completely redisplay
 19498       a window, accepts the window's start point as its argument.
 19499       This is used several times in the redisplay code to control
 19500       where the window start will be, according to user options such
 19501       as scroll-conservatively, and also to ensure the screen line
 19502       showing point will be fully (as opposed to partially) visible on
 19503       display.  */
 19504 
 19505 static void
 19506 redisplay_window (Lisp_Object window, bool just_this_one_p)
 19507 {
 19508   struct window *w = XWINDOW (window);
 19509   struct frame *f = XFRAME (w->frame);
 19510   struct buffer *buffer = XBUFFER (w->contents);
 19511   struct buffer *old = current_buffer;
 19512   struct text_pos lpoint, opoint, startp;
 19513   bool update_mode_line;
 19514   int tem;
 19515   struct it it;
 19516   /* Record it now because it's overwritten.  */
 19517   bool current_matrix_up_to_date_p = false;
 19518   bool used_current_matrix_p = false;
 19519   /* This is less strict than current_matrix_up_to_date_p.
 19520      It indicates that the buffer contents and narrowing are unchanged.  */
 19521   bool buffer_unchanged_p = false;
 19522   bool temp_scroll_step = false;
 19523   specpdl_ref count = SPECPDL_INDEX ();
 19524   int rc;
 19525   int centering_position = -1;
 19526   bool last_line_misfit = false;
 19527   ptrdiff_t beg_unchanged, end_unchanged;
 19528   int frame_line_height, margin;
 19529   bool use_desired_matrix;
 19530   void *itdata = NULL;
 19531 
 19532   SET_TEXT_POS (lpoint, PT, PT_BYTE);
 19533   opoint = lpoint;
 19534 
 19535 #ifdef GLYPH_DEBUG
 19536   *w->desired_matrix->method = 0;
 19537 #endif
 19538 
 19539   if (!just_this_one_p && needs_no_redisplay (w))
 19540     return;
 19541 
 19542   /* Make sure that both W's markers are valid.  */
 19543   eassert (XMARKER (w->start)->buffer == buffer);
 19544   eassert (XMARKER (w->pointm)->buffer == buffer);
 19545 
 19546   reconsider_clip_changes (w);
 19547   frame_line_height = default_line_pixel_height (w);
 19548   margin = window_scroll_margin (w, MARGIN_IN_LINES);
 19549 
 19550 
 19551   /* Has the mode line to be updated?  */
 19552   update_mode_line = (w->update_mode_line
 19553                       || update_mode_lines
 19554                       || buffer->clip_changed
 19555                       || buffer->prevent_redisplay_optimizations_p);
 19556 
 19557   if (!just_this_one_p)
 19558     /* If `just_this_one_p' is set, we apparently set must_be_updated_p more
 19559        cleverly elsewhere.  */
 19560     w->must_be_updated_p = true;
 19561 
 19562   if (MINI_WINDOW_P (w))
 19563     {
 19564       if (w == XWINDOW (echo_area_window)
 19565           && !NILP (echo_area_buffer[0]))
 19566         {
 19567           if (update_mode_line)
 19568             /* We may have to update a tty frame's menu bar or a
 19569                tool-bar.  Example `M-x C-h C-h C-g'.  */
 19570             goto finish_menu_bars;
 19571           else
 19572             /* We've already displayed the echo area glyphs in this window.  */
 19573             goto finish_scroll_bars;
 19574         }
 19575       else if ((w != XWINDOW (minibuf_window)
 19576                 || minibuf_level == 0)
 19577                /* When buffer is nonempty, redisplay window normally.  */
 19578                && BUF_Z (XBUFFER (w->contents)) == BUF_BEG (XBUFFER (w->contents))
 19579                /* Quail displays non-mini buffers in minibuffer window.
 19580                   In that case, redisplay the window normally.  */
 19581                && !NILP (Fmemq (w->contents, Vminibuffer_list)))
 19582         {
 19583           /* W is a mini-buffer window, but it's not active, so clear
 19584              it.  */
 19585           int yb = window_text_bottom_y (w);
 19586           struct glyph_row *row;
 19587           int y;
 19588 
 19589           for (y = 0, row = w->desired_matrix->rows;
 19590                y < yb;
 19591                y += row->height, ++row)
 19592             blank_row (w, row, y);
 19593           goto finish_scroll_bars;
 19594         }
 19595       else if (minibuf_level >= 1)
 19596         {
 19597           /* We could have a message produced by set-minibuffer-message
 19598              displayed in the mini-window as an overlay, so resize the
 19599              mini-window if needed.  */
 19600           resize_mini_window (w, false);
 19601         }
 19602 
 19603       clear_glyph_matrix (w->desired_matrix);
 19604     }
 19605 
 19606   /* Otherwise set up data on this window; select its buffer and point
 19607      value.  */
 19608   /* Really select the buffer, for the sake of buffer-local
 19609      variables.  */
 19610   set_buffer_internal_1 (XBUFFER (w->contents));
 19611 
 19612   current_matrix_up_to_date_p
 19613     = (w->window_end_valid
 19614        && !current_buffer->clip_changed
 19615        && !current_buffer->prevent_redisplay_optimizations_p
 19616        && !window_outdated (w)
 19617        && !composition_break_at_point
 19618        && !hscrolling_current_line_p (w));
 19619 
 19620   beg_unchanged = BEG_UNCHANGED;
 19621   end_unchanged = END_UNCHANGED;
 19622 
 19623   SET_TEXT_POS (opoint, PT, PT_BYTE);
 19624 
 19625   specbind (Qinhibit_point_motion_hooks, Qt);
 19626 
 19627   buffer_unchanged_p
 19628     = (w->window_end_valid
 19629        && !current_buffer->clip_changed
 19630        && !window_outdated (w));
 19631 
 19632   /* When windows_or_buffers_changed is non-zero, we can't rely
 19633      on the window end being valid, so set it to zero there.  */
 19634   if (windows_or_buffers_changed)
 19635     {
 19636       /* If window starts on a continuation line, maybe adjust the
 19637          window start in case the window's width changed.  */
 19638       if (XMARKER (w->start)->buffer == current_buffer)
 19639         compute_window_start_on_continuation_line (w);
 19640 
 19641       w->window_end_valid = false;
 19642       /* If so, we also can't rely on current matrix
 19643          and should not fool try_cursor_movement below.  */
 19644       current_matrix_up_to_date_p = false;
 19645     }
 19646 
 19647   /* Some sanity checks.  */
 19648   CHECK_WINDOW_END (w);
 19649   if (Z == Z_BYTE && CHARPOS (opoint) != BYTEPOS (opoint))
 19650     emacs_abort ();
 19651   if (BYTEPOS (opoint) < CHARPOS (opoint))
 19652     emacs_abort ();
 19653 
 19654   if (mode_line_update_needed (w))
 19655     update_mode_line = true;
 19656 
 19657   /* Point refers normally to the selected window.  For any other
 19658      window, set up appropriate value.  */
 19659   if (!EQ (window, selected_window))
 19660     {
 19661       ptrdiff_t new_pt = marker_position (w->pointm);
 19662       ptrdiff_t new_pt_byte = marker_byte_position (w->pointm);
 19663 
 19664       if (new_pt < BEGV)
 19665         {
 19666           new_pt = BEGV;
 19667           new_pt_byte = BEGV_BYTE;
 19668           set_marker_both (w->pointm, Qnil, BEGV, BEGV_BYTE);
 19669         }
 19670       else if (new_pt > (ZV - 1))
 19671         {
 19672           new_pt = ZV;
 19673           new_pt_byte = ZV_BYTE;
 19674           set_marker_both (w->pointm, Qnil, ZV, ZV_BYTE);
 19675         }
 19676 
 19677       /* We don't use SET_PT so that the point-motion hooks don't run.  */
 19678       TEMP_SET_PT_BOTH (new_pt, new_pt_byte);
 19679     }
 19680 
 19681   /* If any of the character widths specified in the display table
 19682      have changed, invalidate the width run cache.  It's true that
 19683      this may be a bit late to catch such changes, but the rest of
 19684      redisplay goes (non-fatally) haywire when the display table is
 19685      changed, so why should we worry about doing any better?  */
 19686   if (current_buffer->width_run_cache
 19687       || (current_buffer->base_buffer
 19688           && current_buffer->base_buffer->width_run_cache))
 19689     {
 19690       struct Lisp_Char_Table *disptab = buffer_display_table ();
 19691 
 19692       if (! disptab_matches_widthtab
 19693           (disptab, XVECTOR (BVAR (current_buffer, width_table))))
 19694         {
 19695           struct buffer *buf = current_buffer;
 19696 
 19697           if (buf->base_buffer)
 19698             buf = buf->base_buffer;
 19699           invalidate_region_cache (buf, buf->width_run_cache, BEG, Z);
 19700           recompute_width_table (current_buffer, disptab);
 19701         }
 19702     }
 19703 
 19704   /* Check whether the buffer to be displayed contains long lines.  */
 19705   if (!NILP (Vlong_line_threshold)
 19706       && !current_buffer->long_line_optimizations_p
 19707       && (CHARS_MODIFF - UNCHANGED_MODIFIED > 8
 19708           || current_buffer->clip_changed))
 19709     {
 19710       ptrdiff_t cur, next, found, max = 0, threshold;
 19711       threshold = XFIXNUM (Vlong_line_threshold);
 19712       for (cur = BEGV; cur < ZV; cur = next)
 19713         {
 19714           next = find_newline1 (cur, CHAR_TO_BYTE (cur), 0, -1, 1,
 19715                                 &found, NULL, true);
 19716           if (next - cur > max) max = next - cur;
 19717           if (!found || max > threshold) break;
 19718         }
 19719       if (max > threshold)
 19720         current_buffer->long_line_optimizations_p = true;
 19721     }
 19722 
 19723   /* If window-start is screwed up, choose a new one.  */
 19724   if (XMARKER (w->start)->buffer != current_buffer)
 19725     goto recenter;
 19726 
 19727   SET_TEXT_POS_FROM_MARKER (startp, w->start);
 19728 
 19729   /* If someone specified a new starting point but did not insist,
 19730      check whether it can be used.  */
 19731   if ((w->optional_new_start || window_frozen_p (w))
 19732       && CHARPOS (startp) >= BEGV
 19733       && CHARPOS (startp) <= ZV)
 19734     {
 19735       ptrdiff_t it_charpos;
 19736 
 19737       w->optional_new_start = false;
 19738       if (!w->force_start)
 19739         {
 19740           start_display (&it, w, startp);
 19741           move_it_to (&it, PT, 0, it.last_visible_y, -1,
 19742                       MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
 19743           /* Record IT's position now, since line_bottom_y might
 19744              change that.  */
 19745           it_charpos = IT_CHARPOS (it);
 19746           /* Make sure we set the force_start flag only if the cursor
 19747              row will be fully visible.  Otherwise, the code under
 19748              force_start label below will try to move point back into
 19749              view, which is not what the code which sets
 19750              optional_new_start wants.  */
 19751           if (it.current_y == 0 || line_bottom_y (&it) < it.last_visible_y)
 19752             {
 19753               if (it_charpos == PT)
 19754                 w->force_start = true;
 19755               /* IT may overshoot PT if text at PT is invisible.  */
 19756               else if (it_charpos > PT && CHARPOS (startp) <= PT)
 19757                 w->force_start = true;
 19758 #ifdef GLYPH_DEBUG
 19759               if (w->force_start)
 19760                 {
 19761                   if (window_frozen_p (w))
 19762                     debug_method_add (w, "set force_start from frozen window start");
 19763                   else
 19764                     debug_method_add (w, "set force_start from optional_new_start");
 19765                 }
 19766 #endif
 19767             }
 19768         }
 19769     }
 19770 
 19771  force_start:
 19772 
 19773   /* Handle case where place to start displaying has been specified,
 19774      unless the specified location is outside the accessible range.  */
 19775   if (w->force_start)
 19776     {
 19777       /* We set this later on if we have to adjust point.  */
 19778       int new_vpos = -1;
 19779 
 19780       w->force_start = false;
 19781 
 19782       /* The vscroll should be preserved in this case, since
 19783          `pixel-scroll-precision-mode' must continue working normally
 19784          when a mini-window is resized.  (bug#55312) */
 19785       if (!w->preserve_vscroll_p || !window_frozen_p (w))
 19786         w->vscroll = 0;
 19787 
 19788       w->preserve_vscroll_p = false;
 19789       w->window_end_valid = false;
 19790 
 19791       /* Forget any recorded base line for line number display.  */
 19792       if (!buffer_unchanged_p)
 19793         w->base_line_number = 0;
 19794 
 19795       /* Redisplay the mode line.  Select the buffer properly for that.
 19796          Also, run the hook window-scroll-functions
 19797          because we have scrolled.  */
 19798       /* Note, we do this after clearing force_start because
 19799          if there's an error, it is better to forget about force_start
 19800          than to get into an infinite loop calling the hook functions
 19801          and having them get more errors.  */
 19802       if (!update_mode_line
 19803           || ! NILP (Vwindow_scroll_functions))
 19804         {
 19805           update_mode_line = true;
 19806           w->update_mode_line = true;
 19807           startp = run_window_scroll_functions (window, startp);
 19808         }
 19809 
 19810       if (CHARPOS (startp) < BEGV)
 19811         SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
 19812       else if (CHARPOS (startp) > ZV)
 19813         SET_TEXT_POS (startp, ZV, ZV_BYTE);
 19814 
 19815       /* Reject the specified start location if it is invisible, and
 19816          the buffer wants it always visible.  */
 19817       if (!window_start_acceptable_p (window, CHARPOS (startp)))
 19818         goto ignore_start;
 19819 
 19820       /* Redisplay, then check if cursor has been set during the
 19821          redisplay.  Give up if new fonts were loaded.  */
 19822       /* We used to issue a CHECK_MARGINS argument to try_window here,
 19823          but this causes scrolling to fail when point begins inside
 19824          the scroll margin (bug#148) -- cyd  */
 19825       clear_glyph_matrix (w->desired_matrix);
 19826       if (!try_window (window, startp, 0))
 19827         {
 19828           w->force_start = true;
 19829           clear_glyph_matrix (w->desired_matrix);
 19830           goto need_larger_matrices;
 19831         }
 19832 
 19833       if (w->cursor.vpos < 0)
 19834         {
 19835           /* If point does not appear, try to move point so it does
 19836              appear.  The desired matrix has been built above, so we
 19837              can use it here.  First see if point is in invisible
 19838              text, and if so, move it to the first visible buffer
 19839              position past that.  */
 19840           struct glyph_row *r = NULL;
 19841           Lisp_Object invprop =
 19842             get_char_property_and_overlay (make_fixnum (PT), Qinvisible,
 19843                                            Qnil, NULL);
 19844 
 19845           if (TEXT_PROP_MEANS_INVISIBLE (invprop) != 0)
 19846             {
 19847               ptrdiff_t alt_pt;
 19848               Lisp_Object invprop_end =
 19849                 Fnext_single_char_property_change (make_fixnum (PT), Qinvisible,
 19850                                                    Qnil, Qnil);
 19851 
 19852               if (FIXNATP (invprop_end))
 19853                 alt_pt = XFIXNAT (invprop_end);
 19854               else
 19855                 alt_pt = ZV;
 19856               r = row_containing_pos (w, alt_pt, w->desired_matrix->rows,
 19857                                       NULL, 0);
 19858             }
 19859           if (r)
 19860             new_vpos = MATRIX_ROW_BOTTOM_Y (r);
 19861           else  /* Give up and just move to the middle of the window.  */
 19862             new_vpos = window_box_height (w) / 2;
 19863         }
 19864 
 19865       if (!cursor_row_fully_visible_p (w, false, false, false))
 19866         {
 19867           /* Point does appear, but on a line partly visible at end of window.
 19868              Move it back to a fully-visible line.  */
 19869           new_vpos = window_box_height (w);
 19870           /* But if window_box_height suggests a Y coordinate that is
 19871              not less than we already have, that line will clearly not
 19872              be fully visible, so give up and scroll the display.
 19873              This can happen when the default face uses a font whose
 19874              dimensions are different from the frame's default
 19875              font.  */
 19876           if (new_vpos >= w->cursor.y)
 19877             {
 19878               w->cursor.vpos = -1;
 19879               clear_glyph_matrix (w->desired_matrix);
 19880               goto try_to_scroll;
 19881             }
 19882         }
 19883       else if (w->cursor.vpos >= 0)
 19884         {
 19885           /* Some people insist on not letting point enter the scroll
 19886              margin, even though this part handles windows that didn't
 19887              scroll at all.  */
 19888           int pixel_margin = margin * frame_line_height;
 19889           bool tab_line = window_wants_tab_line (w);
 19890           bool header_line = window_wants_header_line (w);
 19891 
 19892           /* Note: We add an extra FRAME_LINE_HEIGHT, because the loop
 19893              below, which finds the row to move point to, advances by
 19894              the Y coordinate of the _next_ row, see the definition of
 19895              MATRIX_ROW_BOTTOM_Y.  */
 19896           if (w->cursor.vpos < margin + tab_line + header_line)
 19897             {
 19898               w->cursor.vpos = -1;
 19899               clear_glyph_matrix (w->desired_matrix);
 19900               goto try_to_scroll;
 19901             }
 19902           else
 19903             {
 19904               int window_height = window_box_height (w);
 19905 
 19906               if (tab_line)
 19907                 window_height += CURRENT_TAB_LINE_HEIGHT (w);
 19908               if (header_line)
 19909                 window_height += CURRENT_HEADER_LINE_HEIGHT (w);
 19910               if (w->cursor.y >= window_height - pixel_margin)
 19911                 {
 19912                   w->cursor.vpos = -1;
 19913                   clear_glyph_matrix (w->desired_matrix);
 19914                   goto try_to_scroll;
 19915                 }
 19916             }
 19917         }
 19918 
 19919       /* If we need to move point for either of the above reasons,
 19920          now actually do it.  */
 19921       if (new_vpos >= 0)
 19922         {
 19923           struct glyph_row *row;
 19924 
 19925           row = MATRIX_FIRST_TEXT_ROW (w->desired_matrix);
 19926           while (MATRIX_ROW_BOTTOM_Y (row) < new_vpos
 19927                  && !row->ends_at_zv_p)
 19928             ++row;
 19929 
 19930           TEMP_SET_PT_BOTH (MATRIX_ROW_START_CHARPOS (row),
 19931                             MATRIX_ROW_START_BYTEPOS (row));
 19932 
 19933           if (w != XWINDOW (selected_window))
 19934             set_marker_both (w->pointm, Qnil, PT, PT_BYTE);
 19935           else if (current_buffer == old)
 19936             SET_TEXT_POS (lpoint, PT, PT_BYTE);
 19937 
 19938           set_cursor_from_row (w, row, w->desired_matrix, 0, 0, 0, 0);
 19939 
 19940           /* Re-run pre-redisplay-function so it can update the region
 19941              according to the new position of point.  */
 19942           /* Other than the cursor, w's redisplay is done so we can set its
 19943              redisplay to false.  Also the buffer's redisplay can be set to
 19944              false, since propagate_buffer_redisplay should have already
 19945              propagated its info to `w' anyway.  */
 19946           w->redisplay = false;
 19947           XBUFFER (w->contents)->text->redisplay = false;
 19948           safe__call1 (true, Vpre_redisplay_function, Fcons (window, Qnil));
 19949 
 19950           if (w->redisplay || XBUFFER (w->contents)->text->redisplay
 19951               || ((EQ (Vdisplay_line_numbers, Qrelative)
 19952                    || EQ (Vdisplay_line_numbers, Qvisual))
 19953                   && row != MATRIX_FIRST_TEXT_ROW (w->desired_matrix)))
 19954             {
 19955               /* Either pre-redisplay-function made changes (e.g. move
 19956                  the region), or we moved point in a window that is
 19957                  under display-line-numbers = relative mode.  We need
 19958                  another round of redisplay.  */
 19959               clear_glyph_matrix (w->desired_matrix);
 19960               if (!try_window (window, startp, 0))
 19961                 goto need_larger_matrices;
 19962             }
 19963         }
 19964       if (w->cursor.vpos < 0
 19965           || !cursor_row_fully_visible_p (w, false, false, false))
 19966         {
 19967           clear_glyph_matrix (w->desired_matrix);
 19968           goto try_to_scroll;
 19969         }
 19970 
 19971 #ifdef GLYPH_DEBUG
 19972       debug_method_add (w, "forced window start");
 19973 #endif
 19974       goto done;
 19975     }
 19976 
 19977  ignore_start:
 19978 
 19979   /* Handle case where text has not changed, only point, and it has
 19980      not moved off the frame, and we are not retrying after hscroll.
 19981      (current_matrix_up_to_date_p is true when retrying.)  */
 19982   if (current_matrix_up_to_date_p
 19983       && (rc = try_cursor_movement (window, startp, &temp_scroll_step),
 19984           rc != CURSOR_MOVEMENT_CANNOT_BE_USED))
 19985     {
 19986       switch (rc)
 19987         {
 19988         case CURSOR_MOVEMENT_SUCCESS:
 19989           used_current_matrix_p = true;
 19990           goto done;
 19991 
 19992         case CURSOR_MOVEMENT_MUST_SCROLL:
 19993           goto try_to_scroll;
 19994 
 19995         default:
 19996           emacs_abort ();
 19997         }
 19998     }
 19999   /* If current starting point was originally the beginning of a line
 20000      but no longer is, or if the starting point is invisible but the
 20001      buffer wants it always visible, find a new starting point.  */
 20002   else if (w->start_at_line_beg
 20003            && ((CHARPOS (startp) > BEGV
 20004                 && FETCH_BYTE (BYTEPOS (startp) - 1) != '\n')
 20005                || (CHARPOS (startp) >= BEGV
 20006                    && CHARPOS (startp) <= ZV
 20007                    && !window_start_acceptable_p (window, CHARPOS (startp)))))
 20008     {
 20009 #ifdef GLYPH_DEBUG
 20010       debug_method_add (w, "recenter 1");
 20011 #endif
 20012       goto recenter;
 20013     }
 20014 
 20015   /* Try scrolling with try_window_id.  Value is > 0 if update has
 20016      been done, it is -1 if we know that the same window start will
 20017      not work.  It is 0 if unsuccessful for some other reason.  */
 20018   else if ((tem = try_window_id (w)) != 0)
 20019     {
 20020 #ifdef GLYPH_DEBUG
 20021       debug_method_add (w, "try_window_id %d", tem);
 20022 #endif
 20023 
 20024       if (f->fonts_changed)
 20025         goto need_larger_matrices;
 20026       if (tem > 0)
 20027         goto done;
 20028 
 20029       /* Otherwise try_window_id has returned -1 which means that we
 20030          don't want the alternative below this comment to execute.  */
 20031     }
 20032   else if (CHARPOS (startp) >= BEGV
 20033            && CHARPOS (startp) <= ZV
 20034            && PT >= CHARPOS (startp)
 20035            && (CHARPOS (startp) < ZV
 20036                /* Avoid starting at end of buffer.  */
 20037                || CHARPOS (startp) == BEGV
 20038                || !window_outdated (w)))
 20039     {
 20040       int d1, d2, d5, d6;
 20041       int rtop, rbot;
 20042 
 20043       /* If first window line is a continuation line, and window start
 20044          is inside the modified region, but the first change is before
 20045          current window start, we must select a new window start.
 20046 
 20047          However, if this is the result of a down-mouse event (e.g. by
 20048          extending the mouse-drag-overlay), we don't want to select a
 20049          new window start, since that would change the position under
 20050          the mouse, resulting in an unwanted mouse-movement rather
 20051          than a simple mouse-click.  */
 20052       if (!w->start_at_line_beg
 20053           && NILP (track_mouse)
 20054           && CHARPOS (startp) > BEGV
 20055           && CHARPOS (startp) > BEG + beg_unchanged
 20056           && CHARPOS (startp) <= Z - end_unchanged
 20057           /* Even if w->start_at_line_beg is nil, a new window may
 20058              start at a line_beg, since that's how set_buffer_window
 20059              sets it.  So, we need to check the return value of
 20060              compute_window_start_on_continuation_line.  (See also
 20061              bug#197).  */
 20062           && XMARKER (w->start)->buffer == current_buffer
 20063           && compute_window_start_on_continuation_line (w)
 20064           /* It doesn't make sense to force the window start like we
 20065              do at label force_start if it is already known that point
 20066              will not be fully visible in the resulting window, because
 20067              doing so will move point from its correct position
 20068              instead of scrolling the window to bring point into view.
 20069              See bug#9324.  */
 20070           && pos_visible_p (w, PT, &d1, &d2, &rtop, &rbot, &d5, &d6)
 20071           /* A very tall row could need more than the window height,
 20072              in which case we accept that it is partially visible.  */
 20073           && (rtop != 0) == (rbot != 0))
 20074         {
 20075           w->force_start = true;
 20076           SET_TEXT_POS_FROM_MARKER (startp, w->start);
 20077 #ifdef GLYPH_DEBUG
 20078           debug_method_add (w, "recomputed window start in continuation line");
 20079 #endif
 20080           goto force_start;
 20081         }
 20082 
 20083       /* Don't use the same window-start if it is invisible or covered
 20084          by a replacing 'display' property and the buffer requested
 20085          the window-start to be always visible.  */
 20086       if (!window_start_acceptable_p (window, CHARPOS (startp)))
 20087         {
 20088 #ifdef GLYPH_DEBUG
 20089           debug_method_add (w, "recenter 2");
 20090 #endif
 20091           goto recenter;
 20092         }
 20093 
 20094 #ifdef GLYPH_DEBUG
 20095       debug_method_add (w, "same window start");
 20096 #endif
 20097 
 20098       /* Try to redisplay starting at same place as before.
 20099          If point has not moved off frame, accept the results.  */
 20100       if (!current_matrix_up_to_date_p
 20101           /* Don't use try_window_reusing_current_matrix in this case
 20102              because a window scroll function can have changed the
 20103              buffer.  */
 20104           || !NILP (Vwindow_scroll_functions)
 20105           || MINI_WINDOW_P (w)
 20106           || !(used_current_matrix_p
 20107                = try_window_reusing_current_matrix (w)))
 20108         {
 20109           IF_DEBUG (debug_method_add (w, "1"));
 20110           clear_glyph_matrix (w->desired_matrix);
 20111           if (try_window (window, startp, TRY_WINDOW_CHECK_MARGINS) < 0)
 20112             /* -1 means we need to scroll.
 20113                0 means we need new matrices, but fonts_changed
 20114                is set in that case, so we will detect it below.  */
 20115             goto try_to_scroll;
 20116         }
 20117 
 20118       if (f->fonts_changed)
 20119         goto need_larger_matrices;
 20120 
 20121       if (w->cursor.vpos >= 0)
 20122         {
 20123           if (!just_this_one_p
 20124               || current_buffer->clip_changed
 20125               || BEG_UNCHANGED < CHARPOS (startp))
 20126             /* Forget any recorded base line for line number display.  */
 20127             w->base_line_number = 0;
 20128 
 20129           if (!cursor_row_fully_visible_p (w, true, false, false))
 20130             {
 20131               clear_glyph_matrix (w->desired_matrix);
 20132               last_line_misfit = true;
 20133             }
 20134             /* Drop through and scroll.  */
 20135           else
 20136             goto done;
 20137         }
 20138       else
 20139         clear_glyph_matrix (w->desired_matrix);
 20140     }
 20141 
 20142  try_to_scroll:
 20143 
 20144   /* Redisplay the mode line.  Select the buffer properly for that.  */
 20145   if (!update_mode_line)
 20146     {
 20147       update_mode_line = true;
 20148       w->update_mode_line = true;
 20149     }
 20150 
 20151   /* Try to scroll by specified few lines.  */
 20152   if ((0 < scroll_conservatively
 20153        /* FIXME: the option is supposed to affect minibuffers, but we
 20154           test MINI_WINDOW_P, which can also catch uses of
 20155           mini-windows for displaying the echo area.  Do we need to
 20156           distinguish these two use cases?  */
 20157        || (scroll_minibuffer_conservatively && MINI_WINDOW_P (w))
 20158        || 0 < emacs_scroll_step
 20159        || temp_scroll_step
 20160        || NUMBERP (BVAR (current_buffer, scroll_up_aggressively))
 20161        || NUMBERP (BVAR (current_buffer, scroll_down_aggressively)))
 20162       && CHARPOS (startp) >= BEGV
 20163       && CHARPOS (startp) <= ZV)
 20164     {
 20165       /* The function returns -1 if new fonts were loaded, 1 if
 20166          successful, 0 if not successful.  */
 20167       int ss = try_scrolling (window, just_this_one_p,
 20168                               ((scroll_minibuffer_conservatively
 20169                                 && MINI_WINDOW_P (w))
 20170                                ? SCROLL_LIMIT + 1
 20171                                : scroll_conservatively),
 20172                               emacs_scroll_step,
 20173                               temp_scroll_step, last_line_misfit);
 20174       switch (ss)
 20175         {
 20176         case SCROLLING_SUCCESS:
 20177           goto done;
 20178 
 20179         case SCROLLING_NEED_LARGER_MATRICES:
 20180           goto need_larger_matrices;
 20181 
 20182         case SCROLLING_FAILED:
 20183           break;
 20184 
 20185         default:
 20186           emacs_abort ();
 20187         }
 20188     }
 20189 
 20190   /* Finally, just choose a place to start which positions point
 20191      according to user preferences.  */
 20192 
 20193  recenter:
 20194 
 20195 #ifdef GLYPH_DEBUG
 20196   debug_method_add (w, "recenter");
 20197 #endif
 20198 
 20199   /* Forget any previously recorded base line for line number display.  */
 20200   if (!buffer_unchanged_p)
 20201     w->base_line_number = 0;
 20202 
 20203   /* Determine the window start relative to point.  */
 20204   init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
 20205   it.current_y = it.last_visible_y;
 20206   if (centering_position < 0)
 20207     {
 20208       ptrdiff_t margin_pos = CHARPOS (startp);
 20209       Lisp_Object aggressive;
 20210       bool scrolling_up;
 20211 
 20212       /* If there is a scroll margin at the top of the window, find
 20213          its character position.  */
 20214       if (margin
 20215           /* Cannot call start_display if startp is not in the
 20216              accessible region of the buffer.  This can happen when we
 20217              have just switched to a different buffer and/or changed
 20218              its restriction.  In that case, startp is initialized to
 20219              the character position 1 (BEGV) because we did not yet
 20220              have chance to display the buffer even once.  */
 20221           && BEGV <= CHARPOS (startp) && CHARPOS (startp) <= ZV)
 20222         {
 20223           struct it it1;
 20224           void *it1data = NULL;
 20225 
 20226           SAVE_IT (it1, it, it1data);
 20227           start_display (&it1, w, startp);
 20228           move_it_vertically (&it1, margin * frame_line_height);
 20229           margin_pos = IT_CHARPOS (it1);
 20230           RESTORE_IT (&it, &it, it1data);
 20231         }
 20232       scrolling_up = PT > margin_pos;
 20233       aggressive =
 20234         scrolling_up
 20235         ? BVAR (current_buffer, scroll_up_aggressively)
 20236         : BVAR (current_buffer, scroll_down_aggressively);
 20237 
 20238       if (!MINI_WINDOW_P (w)
 20239           && (scroll_conservatively > SCROLL_LIMIT || NUMBERP (aggressive)))
 20240         {
 20241           int pt_offset = 0;
 20242 
 20243           /* Setting scroll-conservatively overrides
 20244              scroll-*-aggressively.  */
 20245           if (!scroll_conservatively && NUMBERP (aggressive))
 20246             {
 20247               double float_amount = XFLOATINT (aggressive);
 20248 
 20249               pt_offset = float_amount * WINDOW_BOX_TEXT_HEIGHT (w);
 20250               if (pt_offset == 0 && float_amount > 0)
 20251                 pt_offset = 1;
 20252               if (pt_offset && margin > 0)
 20253                 margin -= 1;
 20254             }
 20255           /* Compute how much to move the window start backward from
 20256              point so that point will be displayed where the user
 20257              wants it.  */
 20258           if (scrolling_up)
 20259             {
 20260               centering_position = it.last_visible_y;
 20261               if (pt_offset)
 20262                 centering_position -= pt_offset;
 20263               centering_position -=
 20264                 (frame_line_height * (1 + margin + last_line_misfit)
 20265                  + WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w));
 20266               /* Don't let point enter the scroll margin near top of
 20267                  the window.  */
 20268               if (centering_position < margin * frame_line_height)
 20269                 centering_position = margin * frame_line_height;
 20270             }
 20271           else
 20272             centering_position = margin * frame_line_height + pt_offset;
 20273         }
 20274       else
 20275         /* Set the window start half the height of the window backward
 20276            from point.  */
 20277         centering_position = window_box_height (w) / 2;
 20278     }
 20279   if (current_buffer->long_line_optimizations_p
 20280       && it.line_wrap == TRUNCATE)
 20281     {
 20282       /* For very long and truncated lines, go back using a simplified
 20283          method, which ignored any inaccuracies due to line-height
 20284          differences, display properties/overlays, etc.  */
 20285       int nlines = centering_position / frame_line_height;
 20286 
 20287       while (nlines-- && IT_CHARPOS (it) > BEGV)
 20288         back_to_previous_visible_line_start (&it);
 20289       reseat_1 (&it, it.current.pos, true);
 20290     }
 20291   else
 20292     move_it_vertically_backward (&it, centering_position);
 20293 
 20294   eassert (IT_CHARPOS (it) >= BEGV);
 20295 
 20296   /* The function move_it_vertically_backward may move over more
 20297      than the specified y-distance.  If it->w is small, e.g. a
 20298      mini-buffer window, we may end up in front of the window's
 20299      display area.  Start displaying at the start of the line
 20300      containing PT in this case.  */
 20301   if (it.current_y <= 0)
 20302     {
 20303       init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
 20304       move_it_vertically_backward (&it, 0);
 20305       it.current_y = 0;
 20306     }
 20307 
 20308   it.current_x = it.hpos = 0;
 20309 
 20310   /* Set the window start position here explicitly, to avoid an
 20311      infinite loop in case the functions in window-scroll-functions
 20312      get errors.  */
 20313   set_marker_both (w->start, Qnil, IT_CHARPOS (it), IT_BYTEPOS (it));
 20314 
 20315   /* Run scroll hooks.  */
 20316   startp = run_window_scroll_functions (window, it.current.pos);
 20317 
 20318   /* We invoke try_window and try_window_reusing_current_matrix below,
 20319      and they manipulate the bidi cache.  Save and restore the cache
 20320      state of our iterator, so we could continue using it after that.  */
 20321   itdata = bidi_shelve_cache ();
 20322 
 20323   /* Redisplay the window.  */
 20324   use_desired_matrix = false;
 20325   if (!current_matrix_up_to_date_p
 20326       || windows_or_buffers_changed
 20327       || f->cursor_type_changed
 20328       /* Don't use try_window_reusing_current_matrix in this case
 20329          because it can have changed the buffer.  */
 20330       || !NILP (Vwindow_scroll_functions)
 20331       || !just_this_one_p
 20332       || MINI_WINDOW_P (w)
 20333       || !(used_current_matrix_p
 20334            = try_window_reusing_current_matrix (w)))
 20335     use_desired_matrix = (try_window (window, startp, 0) == 1);
 20336 
 20337   bidi_unshelve_cache (itdata, false);
 20338 
 20339   /* If new fonts have been loaded (due to fontsets), give up.  We
 20340      have to start a new redisplay since we need to re-adjust glyph
 20341      matrices.  */
 20342   if (f->fonts_changed)
 20343     goto need_larger_matrices;
 20344 
 20345   /* If cursor did not appear assume that the middle of the window is
 20346      in the first line of the window.  Do it again with the next line.
 20347      (Imagine a window of height 100, displaying two lines of height
 20348      60.  Moving back 50 from it->last_visible_y will end in the first
 20349      line.)  */
 20350   if (w->cursor.vpos < 0)
 20351     {
 20352       if (w->window_end_valid && PT >= Z - w->window_end_pos)
 20353         {
 20354           clear_glyph_matrix (w->desired_matrix);
 20355           move_it_by_lines (&it, 1);
 20356           try_window (window, it.current.pos, 0);
 20357         }
 20358       else if (PT < IT_CHARPOS (it))
 20359         {
 20360           clear_glyph_matrix (w->desired_matrix);
 20361           move_it_by_lines (&it, -1);
 20362           try_window (window, it.current.pos, 0);
 20363         }
 20364       else if (scroll_conservatively > SCROLL_LIMIT
 20365                && (it.method == GET_FROM_STRING
 20366                    || overlay_touches_p (IT_CHARPOS (it)))
 20367                && IT_CHARPOS (it) < ZV)
 20368         {
 20369           /* If the window starts with a before-string that spans more
 20370              than one screen line, using that position to display the
 20371              window might fail to bring point into the view, because
 20372              start_display will always start by displaying the string,
 20373              whereas the code above determines where to set w->start
 20374              by the buffer position of the place where it takes screen
 20375              coordinates.  Try to recover by finding the next screen
 20376              line that displays buffer text.  */
 20377           ptrdiff_t pos0 = IT_CHARPOS (it);
 20378 
 20379           clear_glyph_matrix (w->desired_matrix);
 20380           do {
 20381             move_it_by_lines (&it, 1);
 20382           } while (IT_CHARPOS (it) == pos0);
 20383           try_window (window, it.current.pos, 0);
 20384         }
 20385       else
 20386         {
 20387           /* Not much we can do about it.  */
 20388         }
 20389     }
 20390 
 20391   /* Consider the following case: Window starts at BEGV, there is
 20392      invisible, intangible text at BEGV, so that display starts at
 20393      some point START > BEGV.  It can happen that we are called with
 20394      PT somewhere between BEGV and START.  Try to handle that case,
 20395      and similar ones.  */
 20396   if (w->cursor.vpos < 0)
 20397     {
 20398       /* Prefer the desired matrix to the current matrix, if possible,
 20399          in the fallback calculations below.  This is because using
 20400          the current matrix might completely goof, e.g. if its first
 20401          row is after point.  */
 20402       struct glyph_matrix *matrix =
 20403         use_desired_matrix ? w->desired_matrix : w->current_matrix;
 20404       /* First, try locating the proper glyph row for PT.  */
 20405       struct glyph_row *row =
 20406         row_containing_pos (w, PT, matrix->rows, NULL, 0);
 20407 
 20408       /* Sometimes point is at the beginning of invisible text that is
 20409          before the 1st character displayed in the row.  In that case,
 20410          row_containing_pos fails to find the row, because no glyphs
 20411          with appropriate buffer positions are present in the row.
 20412          Therefore, we next try to find the row which shows the 1st
 20413          position after the invisible text.  */
 20414       if (!row)
 20415         {
 20416           Lisp_Object val =
 20417             get_char_property_and_overlay (make_fixnum (PT), Qinvisible,
 20418                                            Qnil, NULL);
 20419 
 20420           if (TEXT_PROP_MEANS_INVISIBLE (val) != 0)
 20421             {
 20422               ptrdiff_t alt_pos;
 20423               Lisp_Object invis_end =
 20424                 Fnext_single_char_property_change (make_fixnum (PT), Qinvisible,
 20425                                                    Qnil, Qnil);
 20426 
 20427               if (FIXNATP (invis_end))
 20428                 alt_pos = XFIXNAT (invis_end);
 20429               else
 20430                 alt_pos = ZV;
 20431               row = row_containing_pos (w, alt_pos, matrix->rows, NULL, 0);
 20432             }
 20433         }
 20434       /* Finally, fall back on the first row of the window after the
 20435          tab-line and header line (if any).  This is slightly better
 20436          than not displaying the cursor at all.  */
 20437       if (!row)
 20438         {
 20439           row = matrix->rows;
 20440           /* Skip the tab-line and header-line rows, if any.  */
 20441           if (row->tab_line_p)
 20442             ++row;
 20443           if (row->mode_line_p)
 20444             ++row;
 20445         }
 20446       set_cursor_from_row (w, row, matrix, 0, 0, 0, 0);
 20447     }
 20448 
 20449   if (!cursor_row_fully_visible_p (w, false, false, false))
 20450     {
 20451       /* If vscroll is enabled, disable it and try again.  */
 20452       if (w->vscroll)
 20453         {
 20454           w->vscroll = 0;
 20455           clear_glyph_matrix (w->desired_matrix);
 20456           goto recenter;
 20457         }
 20458 
 20459       /* Users who set scroll-conservatively to a large number want
 20460          point just above/below the scroll margin.  If we ended up
 20461          with point's row partially visible, move the window start to
 20462          make that row fully visible and out of the margin.  */
 20463       if (scroll_conservatively > SCROLL_LIMIT)
 20464         {
 20465           int window_total_lines
 20466             = WINDOW_TOTAL_LINES (w) * FRAME_LINE_HEIGHT (f) / frame_line_height;
 20467           bool move_down = w->cursor.vpos >= window_total_lines / 2;
 20468 
 20469           move_it_by_lines (&it, move_down ? margin + 1 : -(margin + 1));
 20470           clear_glyph_matrix (w->desired_matrix);
 20471           if (1 == try_window (window, it.current.pos,
 20472                                TRY_WINDOW_CHECK_MARGINS))
 20473             goto done;
 20474         }
 20475 
 20476       /* If centering point failed to make the whole line visible,
 20477          put point at the top instead.  That has to make the whole line
 20478          visible, if it can be done.  */
 20479       if (centering_position == 0)
 20480         goto done;
 20481 
 20482       clear_glyph_matrix (w->desired_matrix);
 20483       centering_position = 0;
 20484       goto recenter;
 20485     }
 20486 
 20487  done:
 20488 
 20489   SET_TEXT_POS_FROM_MARKER (startp, w->start);
 20490   w->start_at_line_beg = (CHARPOS (startp) == BEGV
 20491                           || FETCH_BYTE (BYTEPOS (startp) - 1) == '\n');
 20492 
 20493   /* Display the mode line, header line, and tab-line, if we must.  */
 20494   if ((update_mode_line
 20495        /* If window not full width, must redo its mode line
 20496           if (a) the window to its side is being redone and
 20497           (b) we do a frame-based redisplay.  This is a consequence
 20498           of how inverted lines are drawn in frame-based redisplay.  */
 20499        || (!just_this_one_p
 20500            && !FRAME_WINDOW_P (f)
 20501            && !WINDOW_FULL_WIDTH_P (w))
 20502        /* Line number to display.  */
 20503        || w->base_line_pos > 0
 20504        /* Column number is displayed and different from the one displayed.  */
 20505        || (w->column_number_displayed != -1
 20506            && (w->column_number_displayed != current_column ())))
 20507       /* This means that the window has a mode line.  */
 20508       && (window_wants_mode_line (w)
 20509           || window_wants_header_line (w)
 20510           || window_wants_tab_line (w)))
 20511     {
 20512       specpdl_ref count1 = SPECPDL_INDEX ();
 20513 
 20514       specbind (Qinhibit_quit, Qt);
 20515       display_mode_lines (w);
 20516       unbind_to (count1, Qnil);
 20517 
 20518       /* If mode line height has changed, arrange for a thorough
 20519          immediate redisplay using the correct mode line height.  */
 20520       if (window_wants_mode_line (w)
 20521           && CURRENT_MODE_LINE_HEIGHT (w) != DESIRED_MODE_LINE_HEIGHT (w))
 20522         {
 20523           f->fonts_changed = true;
 20524           w->mode_line_height = -1;
 20525           MATRIX_MODE_LINE_ROW (w->current_matrix)->height
 20526             = DESIRED_MODE_LINE_HEIGHT (w);
 20527         }
 20528 
 20529       /* If tab line height has changed, arrange for a thorough
 20530          immediate redisplay using the correct tab line height.  */
 20531       if (window_wants_tab_line (w)
 20532           && CURRENT_TAB_LINE_HEIGHT (w) != DESIRED_TAB_LINE_HEIGHT (w))
 20533         {
 20534           f->fonts_changed = true;
 20535           w->tab_line_height = -1;
 20536           MATRIX_TAB_LINE_ROW (w->current_matrix)->height
 20537             = DESIRED_TAB_LINE_HEIGHT (w);
 20538         }
 20539 
 20540       /* If header line height has changed, arrange for a thorough
 20541          immediate redisplay using the correct header line height.  */
 20542       if (window_wants_header_line (w)
 20543           && CURRENT_HEADER_LINE_HEIGHT (w) != DESIRED_HEADER_LINE_HEIGHT (w))
 20544         {
 20545           f->fonts_changed = true;
 20546           w->header_line_height = -1;
 20547           MATRIX_HEADER_LINE_ROW (w->current_matrix)->height
 20548             = DESIRED_HEADER_LINE_HEIGHT (w);
 20549         }
 20550 
 20551       if (f->fonts_changed)
 20552         goto need_larger_matrices;
 20553     }
 20554 
 20555   if (!line_number_displayed && w->base_line_pos != -1)
 20556     {
 20557       w->base_line_pos = 0;
 20558       w->base_line_number = 0;
 20559     }
 20560 
 20561  finish_menu_bars:
 20562 
 20563   /* When we reach a frame's selected window, redo the frame's menu
 20564      bar, tool bar, tab-bar, and the frame's title.  */
 20565   if (update_mode_line
 20566       && EQ (FRAME_SELECTED_WINDOW (f), window))
 20567     {
 20568       bool redisplay_menu_p;
 20569 
 20570       if (FRAME_WINDOW_P (f))
 20571         {
 20572 #ifdef HAVE_EXT_MENU_BAR
 20573           redisplay_menu_p = FRAME_EXTERNAL_MENU_BAR (f);
 20574 #else
 20575           redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
 20576 #endif
 20577         }
 20578       else
 20579         redisplay_menu_p = FRAME_MENU_BAR_LINES (f) > 0;
 20580 
 20581       if (redisplay_menu_p)
 20582         display_menu_bar (w);
 20583 
 20584 #ifdef HAVE_WINDOW_SYSTEM
 20585       if (FRAME_WINDOW_P (f))
 20586         {
 20587           if (WINDOWP (f->tab_bar_window)
 20588               && (FRAME_TAB_BAR_LINES (f) > 0
 20589                   || !NILP (Vauto_resize_tab_bars))
 20590               && redisplay_tab_bar (f))
 20591             ignore_mouse_drag_p = true;
 20592 
 20593 #ifdef HAVE_EXT_TOOL_BAR
 20594           if (FRAME_EXTERNAL_TOOL_BAR (f))
 20595             update_frame_tool_bar (f);
 20596 #else
 20597           if (WINDOWP (f->tool_bar_window)
 20598               && (FRAME_TOOL_BAR_LINES (f) > 0
 20599                   || !NILP (Vauto_resize_tool_bars))
 20600               && redisplay_tool_bar (f))
 20601             ignore_mouse_drag_p = true;
 20602 #endif
 20603         }
 20604       else
 20605         {
 20606           if ((FRAME_TAB_BAR_LINES (f) > 0))
 20607             display_tab_bar (w);
 20608         }
 20609 
 20610       gui_consider_frame_title (w->frame);
 20611 #else
 20612       if ((FRAME_TAB_BAR_LINES (f) > 0))
 20613         display_tab_bar (w);
 20614 #endif
 20615     }
 20616 
 20617 #ifdef HAVE_WINDOW_SYSTEM
 20618   if (FRAME_WINDOW_P (f)
 20619       && update_window_fringes (w, (just_this_one_p
 20620                                     || (!used_current_matrix_p && !overlay_arrow_seen)
 20621                                     || w->pseudo_window_p)))
 20622     {
 20623       update_begin (f);
 20624       block_input ();
 20625       if (draw_window_fringes (w, true))
 20626         {
 20627           if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
 20628             gui_draw_right_divider (w);
 20629           else
 20630             gui_draw_vertical_border (w);
 20631         }
 20632       unblock_input ();
 20633       update_end (f);
 20634     }
 20635 
 20636   if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
 20637     gui_draw_bottom_divider (w);
 20638 #endif /* HAVE_WINDOW_SYSTEM */
 20639 
 20640   /* We go to this label, with fonts_changed set, if it is
 20641      necessary to try again using larger glyph matrices.
 20642      We have to redeem the scroll bar even in this case,
 20643      because the loop in redisplay_internal expects that.  */
 20644  need_larger_matrices:
 20645   ;
 20646  finish_scroll_bars:
 20647 
 20648    if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w) || WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w))
 20649     {
 20650       if (WINDOW_HAS_VERTICAL_SCROLL_BAR (w))
 20651         /* Set the thumb's position and size.  */
 20652         set_vertical_scroll_bar (w);
 20653 
 20654       if (WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w))
 20655         /* Set the thumb's position and size.  */
 20656         set_horizontal_scroll_bar (w);
 20657 
 20658       /* Note that we actually used the scroll bar attached to this
 20659          window, so it shouldn't be deleted at the end of redisplay.  */
 20660       if (FRAME_TERMINAL (f)->redeem_scroll_bar_hook)
 20661         (*FRAME_TERMINAL (f)->redeem_scroll_bar_hook) (w);
 20662     }
 20663 
 20664   /* Restore current_buffer and value of point in it.  The window
 20665      update may have changed the buffer, so first make sure `opoint'
 20666      is still valid (Bug#6177).  */
 20667   if (CHARPOS (opoint) < BEGV)
 20668     TEMP_SET_PT_BOTH (BEGV, BEGV_BYTE);
 20669   else if (CHARPOS (opoint) > ZV)
 20670     TEMP_SET_PT_BOTH (Z, Z_BYTE);
 20671   else
 20672     TEMP_SET_PT_BOTH (CHARPOS (opoint), BYTEPOS (opoint));
 20673 
 20674   set_buffer_internal_1 (old);
 20675   /* Avoid an abort in TEMP_SET_PT_BOTH if the buffer has become
 20676      shorter.  This can be caused by log truncation in *Messages*.  */
 20677   if (CHARPOS (lpoint) <= ZV)
 20678     TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
 20679 
 20680   unbind_to (count, Qnil);
 20681 }
 20682 
 20683 
 20684 /* Build the complete desired matrix of WINDOW with a window start
 20685    buffer position POS.
 20686 
 20687    Value is 1 if successful.  It is zero if fonts were loaded during
 20688    redisplay or the dimensions of the desired matrix were found
 20689    insufficient, which makes re-adjusting glyph matrices necessary.
 20690    Value is -1 if point would appear in the scroll margins.  (We check
 20691    the former only if TRY_WINDOW_IGNORE_FONTS_CHANGE is unset in
 20692    FLAGS, and the latter only if TRY_WINDOW_CHECK_MARGINS is set in
 20693    FLAGS.)
 20694 
 20695    Note that 'x-show-tip' invokes this function in a special way, and
 20696    in that case the return value of zero doesn't necessarily mean the
 20697    glyph matrices need to be re-adjusted, if the entire text of the
 20698    tooltip was processed and has its glyphs in the matrix's glyph
 20699    rows, i.e. if the dimensions of the matrix were found insufficient
 20700    while producing empty glyph rows beyond ZV.  */
 20701 
 20702 int
 20703 try_window (Lisp_Object window, struct text_pos pos, int flags)
 20704 {
 20705   struct window *w = XWINDOW (window);
 20706   struct it it;
 20707   struct glyph_row *last_text_row = NULL;
 20708   struct frame *f = XFRAME (w->frame);
 20709   int cursor_vpos = w->cursor.vpos;
 20710 
 20711   /* Make POS the new window start.  */
 20712   set_marker_both (w->start, Qnil, CHARPOS (pos), BYTEPOS (pos));
 20713 
 20714   /* Mark cursor position as unknown.  No overlay arrow seen.  */
 20715   w->cursor.vpos = -1;
 20716   overlay_arrow_seen = false;
 20717 
 20718   /* Initialize iterator and info to start at POS.  */
 20719   start_display (&it, w, pos);
 20720   it.glyph_row->reversed_p = false;
 20721 
 20722   /* Display all lines of W.  */
 20723   while (it.current_y < it.last_visible_y)
 20724     {
 20725       int last_row_scale = it.w->nrows_scale_factor;
 20726       int last_col_scale = it.w->ncols_scale_factor;
 20727       if (display_line (&it, cursor_vpos))
 20728         last_text_row = it.glyph_row - 1;
 20729       if (f->fonts_changed
 20730           && !((flags & TRY_WINDOW_IGNORE_FONTS_CHANGE)
 20731                /* If the matrix dimensions are insufficient, we _must_
 20732                   fail and let dispnew.c reallocate the matrix.  */
 20733                && last_row_scale == it.w->nrows_scale_factor
 20734                && last_col_scale == it.w->ncols_scale_factor))
 20735         return 0;
 20736     }
 20737 
 20738   /* Save the character position of 'it' before we call
 20739      'start_display' again.  */
 20740   ptrdiff_t it_charpos = IT_CHARPOS (it);
 20741 
 20742   /* Don't let the cursor end in the scroll margins.  However, when
 20743      the window is vscrolled, we leave it to vscroll to handle the
 20744      margins, see window_scroll_pixel_based.  */
 20745   if ((flags & TRY_WINDOW_CHECK_MARGINS)
 20746       && w->vscroll == 0
 20747       && !MINI_WINDOW_P (w))
 20748     {
 20749       int top_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 20750       int bot_scroll_margin = top_scroll_margin;
 20751       if (window_wants_header_line (w))
 20752         top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
 20753       if (window_wants_tab_line (w))
 20754         top_scroll_margin += CURRENT_TAB_LINE_HEIGHT (w);
 20755       start_display (&it, w, pos);
 20756 
 20757       if ((w->cursor.y >= 0
 20758            && w->cursor.y < top_scroll_margin
 20759            && CHARPOS (pos) > BEGV)
 20760           /* rms: considering make_cursor_line_fully_visible_p here
 20761              seems to give wrong results.  We don't want to recenter
 20762              when the last line is partly visible, we want to allow
 20763              that case to be handled in the usual way.  */
 20764           || w->cursor.y > (it.last_visible_y - partial_line_height (&it)
 20765                             - bot_scroll_margin - 1))
 20766         {
 20767           w->cursor.vpos = -1;
 20768           clear_glyph_matrix (w->desired_matrix);
 20769           return -1;
 20770         }
 20771     }
 20772 
 20773   /* If bottom moved off end of frame, change mode line percentage.  */
 20774   if (w->window_end_pos <= 0 && Z != it_charpos)
 20775     w->update_mode_line = true;
 20776 
 20777   /* Set window_end_pos to the offset of the last character displayed
 20778      on the window from the end of current_buffer.  Set
 20779      window_end_vpos to its row number.  */
 20780   if (last_text_row)
 20781     {
 20782       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_text_row));
 20783       adjust_window_ends (w, last_text_row, false);
 20784       eassert
 20785         (MATRIX_ROW_DISPLAYS_TEXT_P (MATRIX_ROW (w->desired_matrix,
 20786                                                  w->window_end_vpos)));
 20787     }
 20788   else
 20789     {
 20790       w->window_end_bytepos = Z_BYTE - ZV_BYTE;
 20791       w->window_end_pos = Z - ZV;
 20792       w->window_end_vpos = 0;
 20793     }
 20794 
 20795   /* But that is not valid info until redisplay finishes.  */
 20796   w->window_end_valid = false;
 20797   return 1;
 20798 }
 20799 
 20800 
 20801 
 20802 /************************************************************************
 20803     Window redisplay reusing current matrix when buffer has not changed
 20804  ************************************************************************/
 20805 
 20806 /* Try redisplay of window W showing an unchanged buffer with a
 20807    different window start than the last time it was displayed by
 20808    reusing its current matrix.  Value is true if successful.
 20809    W->start is the new window start.  */
 20810 
 20811 static bool
 20812 try_window_reusing_current_matrix (struct window *w)
 20813 {
 20814   struct frame *f = XFRAME (w->frame);
 20815   struct glyph_row *bottom_row;
 20816   struct it it;
 20817   struct run run;
 20818   struct text_pos start, new_start;
 20819   int nrows_scrolled, i;
 20820   struct glyph_row *last_text_row;
 20821   struct glyph_row *last_reused_text_row;
 20822   struct glyph_row *start_row;
 20823   int start_vpos, min_y, max_y;
 20824 
 20825 #ifdef GLYPH_DEBUG
 20826   if (inhibit_try_window_reusing)
 20827     return false;
 20828 #endif
 20829 
 20830   if (/* This function doesn't handle terminal frames.  */
 20831       !FRAME_WINDOW_P (f)
 20832       /* Don't try to reuse the display if windows have been split
 20833          or such.  */
 20834       || windows_or_buffers_changed
 20835       || f->cursor_type_changed
 20836       /* This function cannot handle buffers where the overlay arrow
 20837          is shown on the fringes, because if the arrow position
 20838          changes, we cannot just reuse the current matrix.  */
 20839       || overlay_arrow_in_current_buffer_p ())
 20840     return false;
 20841 
 20842   /* Can't do this if showing trailing whitespace.  */
 20843   if (!NILP (Vshow_trailing_whitespace))
 20844     return false;
 20845 
 20846   /* If top-line visibility has changed, give up.  */
 20847   if (window_wants_tab_line (w)
 20848       != MATRIX_TAB_LINE_ROW (w->current_matrix)->mode_line_p)
 20849     return false;
 20850 
 20851   /* If top-line visibility has changed, give up.  */
 20852   if (window_wants_header_line (w)
 20853       != MATRIX_HEADER_LINE_ROW (w->current_matrix)->mode_line_p)
 20854     return false;
 20855 
 20856   /* Give up if old or new display is scrolled vertically.  We could
 20857      make this function handle this, but right now it doesn't.  */
 20858   start_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 20859   if (w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row))
 20860     return false;
 20861 
 20862   /* Clear the desired matrix for the display below.  */
 20863   clear_glyph_matrix (w->desired_matrix);
 20864 
 20865   /* Give up if line numbers are being displayed, because reusing the
 20866      current matrix might use the wrong width for line-number
 20867      display.  */
 20868   if (!NILP (Vdisplay_line_numbers))
 20869     return false;
 20870 
 20871   /* Can't scroll the display of w32 GUI frames when position of point
 20872      is indicated by the system caret, because scrolling the display
 20873      will then "copy" the pixels used by the caret.  */
 20874 #ifdef HAVE_NTGUI
 20875   if (w32_use_visible_system_caret)
 20876     return false;
 20877 #endif
 20878 
 20879   /* The variable new_start now holds the new window start.  The old
 20880      start `start' can be determined from the current matrix.  */
 20881   SET_TEXT_POS_FROM_MARKER (new_start, w->start);
 20882   start = start_row->minpos;
 20883   start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
 20884 
 20885   if (CHARPOS (new_start) <= CHARPOS (start))
 20886     {
 20887       /* Don't use this method if the display starts with an ellipsis
 20888          displayed for invisible text.  It's not easy to handle that case
 20889          below, and it's certainly not worth the effort since this is
 20890          not a frequent case.  */
 20891       if (in_ellipses_for_invisible_text_p (&start_row->start, w))
 20892         return false;
 20893 
 20894       IF_DEBUG (debug_method_add (w, "twu1"));
 20895 
 20896       /* Display up to a row that can be reused.  The variable
 20897          last_text_row is set to the last row displayed that displays
 20898          text.  Note that it.vpos == 0 if or if not there is a
 20899          header-line; it's not the same as the MATRIX_ROW_VPOS!  */
 20900       start_display (&it, w, new_start);
 20901       w->cursor.vpos = -1;
 20902       last_text_row = last_reused_text_row = NULL;
 20903 
 20904       while (it.current_y < it.last_visible_y && !f->fonts_changed)
 20905         {
 20906           /* If we have reached into the characters in the START row,
 20907              that means the line boundaries have changed.  So we
 20908              can't start copying with the row START.  Maybe it will
 20909              work to start copying with the following row.  */
 20910           while (IT_CHARPOS (it) > CHARPOS (start))
 20911             {
 20912               /* Advance to the next row as the "start".  */
 20913               start_row++;
 20914               start = start_row->minpos;
 20915               /* If there are no more rows to try, or just one, give up.  */
 20916               if (start_row == MATRIX_MODE_LINE_ROW (w->current_matrix) - 1
 20917                   || w->vscroll || MATRIX_ROW_PARTIALLY_VISIBLE_P (w, start_row)
 20918                   || CHARPOS (start) == ZV)
 20919                 {
 20920                   clear_glyph_matrix (w->desired_matrix);
 20921                   return false;
 20922                 }
 20923 
 20924               start_vpos = MATRIX_ROW_VPOS (start_row, w->current_matrix);
 20925             }
 20926           /* If we have reached alignment, we can copy the rest of the
 20927              rows.  */
 20928           if (IT_CHARPOS (it) == CHARPOS (start)
 20929               /* Don't accept "alignment" inside a display vector,
 20930                  since start_row could have started in the middle of
 20931                  that same display vector (thus their character
 20932                  positions match), and we have no way of telling if
 20933                  that is the case.  */
 20934               && it.current.dpvec_index < 0)
 20935             break;
 20936 
 20937           it.glyph_row->reversed_p = false;
 20938           if (display_line (&it, -1))
 20939             last_text_row = it.glyph_row - 1;
 20940 
 20941         }
 20942 
 20943       /* A value of current_y < last_visible_y means that we stopped
 20944          at the previous window start, which in turn means that we
 20945          have at least one reusable row.  */
 20946       if (it.current_y < it.last_visible_y)
 20947         {
 20948           struct glyph_row *row;
 20949 
 20950           /* IT.vpos always starts from 0; it counts text lines.  */
 20951           nrows_scrolled = it.vpos - (start_row - MATRIX_FIRST_TEXT_ROW (w->current_matrix));
 20952 
 20953           /* Find PT if not already found in the lines displayed.  */
 20954           if (w->cursor.vpos < 0)
 20955             {
 20956               int dy = it.current_y - start_row->y;
 20957 
 20958               row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 20959               row = row_containing_pos (w, PT, row, NULL, dy);
 20960               if (row)
 20961                 set_cursor_from_row (w, row, w->current_matrix, 0, 0,
 20962                                      dy, nrows_scrolled);
 20963               else
 20964                 {
 20965                   clear_glyph_matrix (w->desired_matrix);
 20966                   return false;
 20967                 }
 20968             }
 20969 
 20970           /* Scroll the display.  Do it before the current matrix is
 20971              changed.  The problem here is that update has not yet
 20972              run, i.e. part of the current matrix is not up to date.
 20973              scroll_run_hook will clear the cursor, and use the
 20974              current matrix to get the height of the row the cursor is
 20975              in.  */
 20976           run.current_y = start_row->y;
 20977           run.desired_y = it.current_y;
 20978           run.height = it.last_visible_y - it.current_y;
 20979 
 20980           if (run.height > 0 && run.current_y != run.desired_y)
 20981             {
 20982 #ifdef HAVE_WINDOW_SYSTEM
 20983               update_begin (f);
 20984               gui_update_window_begin (w);
 20985               FRAME_RIF (f)->clear_window_mouse_face (w);
 20986               FRAME_RIF (f)->scroll_run_hook (w, &run);
 20987               gui_update_window_end (w, false, false);
 20988               update_end (f);
 20989 #endif
 20990             }
 20991 
 20992           /* Shift current matrix down by nrows_scrolled lines.  */
 20993           bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
 20994           rotate_matrix (w->current_matrix,
 20995                          start_vpos,
 20996                          MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
 20997                          nrows_scrolled);
 20998 
 20999           /* Disable lines that must be updated.  */
 21000           for (i = 0; i < nrows_scrolled; ++i)
 21001             (start_row + i)->enabled_p = false;
 21002 
 21003           /* Re-compute Y positions.  */
 21004           min_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 21005           max_y = it.last_visible_y;
 21006           for (row = start_row + nrows_scrolled;
 21007                row < bottom_row;
 21008                ++row)
 21009             {
 21010               row->y = it.current_y;
 21011               row->visible_height = row->height;
 21012 
 21013               if (row->y < min_y)
 21014                 row->visible_height -= min_y - row->y;
 21015               if (row->y + row->height > max_y)
 21016                 row->visible_height -= row->y + row->height - max_y;
 21017               if (row->fringe_bitmap_periodic_p)
 21018                 row->redraw_fringe_bitmaps_p = true;
 21019 
 21020               it.current_y += row->height;
 21021 
 21022               if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21023                 last_reused_text_row = row;
 21024               if (MATRIX_ROW_BOTTOM_Y (row) >= it.last_visible_y)
 21025                 break;
 21026             }
 21027 
 21028           /* Disable lines in the current matrix which are now
 21029              below the window.  */
 21030           for (++row; row < bottom_row; ++row)
 21031             row->enabled_p = row->mode_line_p = row->tab_line_p = false;
 21032         }
 21033 
 21034       /* Update window_end_pos etc.; last_reused_text_row is the last
 21035          reused row from the current matrix containing text, if any.
 21036          The value of last_text_row is the last displayed line
 21037          containing text.  */
 21038       if (last_reused_text_row)
 21039         adjust_window_ends (w, last_reused_text_row, true);
 21040       else if (last_text_row)
 21041         adjust_window_ends (w, last_text_row, false);
 21042       else
 21043         {
 21044           /* This window must be completely empty.  */
 21045           w->window_end_bytepos = Z_BYTE - ZV_BYTE;
 21046           w->window_end_pos = Z - ZV;
 21047           w->window_end_vpos = 0;
 21048         }
 21049       w->window_end_valid = false;
 21050 
 21051       /* Update hint: don't try scrolling again in update_window.  */
 21052       w->desired_matrix->no_scrolling_p = true;
 21053 
 21054 #ifdef GLYPH_DEBUG
 21055       debug_method_add (w, "try_window_reusing_current_matrix 1");
 21056 #endif
 21057       return true;
 21058     }
 21059   else if (CHARPOS (new_start) > CHARPOS (start))
 21060     {
 21061       struct glyph_row *pt_row, *row;
 21062       struct glyph_row *first_reusable_row;
 21063       struct glyph_row *first_row_to_display;
 21064       int dy;
 21065       int yb = window_text_bottom_y (w);
 21066 
 21067       /* Find the row starting at new_start, if there is one.  Don't
 21068          reuse a partially visible line at the end.  */
 21069       first_reusable_row = start_row;
 21070       while (first_reusable_row->enabled_p
 21071              && MATRIX_ROW_BOTTOM_Y (first_reusable_row) < yb
 21072              && (MATRIX_ROW_START_CHARPOS (first_reusable_row)
 21073                  < CHARPOS (new_start)))
 21074         ++first_reusable_row;
 21075 
 21076       /* Give up if there is no row to reuse.  */
 21077       if (MATRIX_ROW_BOTTOM_Y (first_reusable_row) >= yb
 21078           || !first_reusable_row->enabled_p
 21079           || (MATRIX_ROW_START_CHARPOS (first_reusable_row)
 21080               != CHARPOS (new_start)))
 21081         return false;
 21082 
 21083       /* We can reuse fully visible rows beginning with
 21084          first_reusable_row to the end of the window.  Set
 21085          first_row_to_display to the first row that cannot be reused.
 21086          Set pt_row to the row containing point, if there is any.  */
 21087       pt_row = NULL;
 21088       for (first_row_to_display = first_reusable_row;
 21089            MATRIX_ROW_BOTTOM_Y (first_row_to_display) < yb;
 21090            ++first_row_to_display)
 21091         {
 21092           if (PT >= MATRIX_ROW_START_CHARPOS (first_row_to_display)
 21093               && (PT < MATRIX_ROW_END_CHARPOS (first_row_to_display)
 21094                   || (PT == MATRIX_ROW_END_CHARPOS (first_row_to_display)
 21095                       && first_row_to_display->ends_at_zv_p
 21096                       && pt_row == NULL)))
 21097             pt_row = first_row_to_display;
 21098         }
 21099 
 21100       if (first_row_to_display->y >= yb)
 21101         return false;
 21102 
 21103       /* Start displaying at the start of first_row_to_display.  */
 21104       init_to_row_start (&it, w, first_row_to_display);
 21105 
 21106       nrows_scrolled = (MATRIX_ROW_VPOS (first_reusable_row, w->current_matrix)
 21107                         - start_vpos);
 21108       it.vpos = (MATRIX_ROW_VPOS (first_row_to_display, w->current_matrix)
 21109                  - nrows_scrolled);
 21110       it.current_y = (first_row_to_display->y - first_reusable_row->y
 21111                       + WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w));
 21112 
 21113       /* Display lines beginning with first_row_to_display in the
 21114          desired matrix.  Set last_text_row to the last row displayed
 21115          that displays text.  */
 21116       it.glyph_row = MATRIX_ROW (w->desired_matrix, it.vpos);
 21117       if (pt_row == NULL)
 21118         w->cursor.vpos = -1;
 21119       last_text_row = NULL;
 21120       while (it.current_y < it.last_visible_y && !f->fonts_changed)
 21121         if (display_line (&it, w->cursor.vpos))
 21122           last_text_row = it.glyph_row - 1;
 21123 
 21124       /* If point is in a reused row, adjust y and vpos of the cursor
 21125          position.  */
 21126       if (pt_row)
 21127         {
 21128           w->cursor.vpos -= nrows_scrolled;
 21129           w->cursor.y -= first_reusable_row->y - start_row->y;
 21130         }
 21131 
 21132       /* Give up if point isn't in a row displayed or reused.  (This
 21133          also handles the case where w->cursor.vpos < nrows_scrolled
 21134          after the calls to display_line, which can happen with scroll
 21135          margins.  See bug#1295.)  */
 21136       if (w->cursor.vpos < 0)
 21137         {
 21138           clear_glyph_matrix (w->desired_matrix);
 21139           return false;
 21140         }
 21141 
 21142       /* Scroll the display.  */
 21143       run.current_y = first_reusable_row->y;
 21144       run.desired_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 21145       run.height = it.last_visible_y - run.current_y;
 21146       dy = run.current_y - run.desired_y;
 21147 
 21148       if (run.height)
 21149         {
 21150 #ifdef HAVE_WINDOW_SYSTEM
 21151           update_begin (f);
 21152           gui_update_window_begin (w);
 21153           FRAME_RIF (f)->clear_window_mouse_face (w);
 21154           FRAME_RIF (f)->scroll_run_hook (w, &run);
 21155           gui_update_window_end (w, false, false);
 21156           update_end (f);
 21157 #endif
 21158         }
 21159 
 21160       /* Adjust Y positions of reused rows.  */
 21161       bottom_row = MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w);
 21162       min_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 21163       max_y = it.last_visible_y;
 21164       for (row = first_reusable_row; row < first_row_to_display; ++row)
 21165         {
 21166           row->y -= dy;
 21167           row->visible_height = row->height;
 21168           if (row->y < min_y)
 21169             row->visible_height -= min_y - row->y;
 21170           if (row->y + row->height > max_y)
 21171             row->visible_height -= row->y + row->height - max_y;
 21172           if (row->fringe_bitmap_periodic_p)
 21173             row->redraw_fringe_bitmaps_p = true;
 21174         }
 21175 
 21176       /* Scroll the current matrix.  */
 21177       eassert (nrows_scrolled > 0);
 21178       rotate_matrix (w->current_matrix,
 21179                      start_vpos,
 21180                      MATRIX_ROW_VPOS (bottom_row, w->current_matrix),
 21181                      -nrows_scrolled);
 21182 
 21183       /* Disable rows not reused.  */
 21184       for (row -= nrows_scrolled; row < bottom_row; ++row)
 21185         row->enabled_p = false;
 21186 
 21187       /* Point may have moved to a different line, so we cannot assume that
 21188          the previous cursor position is valid; locate the correct row.  */
 21189       if (pt_row)
 21190         {
 21191           for (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos);
 21192                row < bottom_row
 21193                  && PT >= MATRIX_ROW_END_CHARPOS (row)
 21194                  && !row->ends_at_zv_p;
 21195                row++)
 21196             {
 21197               w->cursor.vpos++;
 21198               w->cursor.y = row->y;
 21199             }
 21200           if (row < bottom_row)
 21201             {
 21202               /* Can't simply scan the row for point with
 21203                  bidi-reordered glyph rows.  Let set_cursor_from_row
 21204                  figure out where to put the cursor, and if it fails,
 21205                  give up.  */
 21206               if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering)))
 21207                 {
 21208                   if (!set_cursor_from_row (w, row, w->current_matrix,
 21209                                             0, 0, 0, 0))
 21210                     {
 21211                       clear_glyph_matrix (w->desired_matrix);
 21212                       return false;
 21213                     }
 21214                 }
 21215               else
 21216                 {
 21217                   struct glyph *glyph = row->glyphs[TEXT_AREA] + w->cursor.hpos;
 21218                   struct glyph *end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 21219 
 21220                   for (; glyph < end
 21221                          && (!BUFFERP (glyph->object)
 21222                              || glyph->charpos < PT);
 21223                        glyph++)
 21224                     {
 21225                       w->cursor.hpos++;
 21226                       w->cursor.x += glyph->pixel_width;
 21227                     }
 21228                 }
 21229             }
 21230         }
 21231 
 21232       /* Adjust window end.  A null value of last_text_row means that
 21233          the window end is in reused rows which in turn means that
 21234          only its vpos can have changed.  */
 21235       if (last_text_row)
 21236         adjust_window_ends (w, last_text_row, false);
 21237       else
 21238         w->window_end_vpos -= nrows_scrolled;
 21239 
 21240       w->window_end_valid = false;
 21241       w->desired_matrix->no_scrolling_p = true;
 21242 
 21243 #ifdef GLYPH_DEBUG
 21244       debug_method_add (w, "try_window_reusing_current_matrix 2");
 21245 #endif
 21246       return true;
 21247     }
 21248 
 21249   return false;
 21250 }
 21251 
 21252 
 21253 
 21254 /************************************************************************
 21255    Window redisplay reusing current matrix when buffer has changed
 21256  ************************************************************************/
 21257 
 21258 static struct glyph_row *find_last_unchanged_at_beg_row (struct window *);
 21259 static struct glyph_row *find_first_unchanged_at_end_row (struct window *,
 21260                                                           ptrdiff_t *, ptrdiff_t *);
 21261 static struct glyph_row *
 21262 find_last_row_displaying_text (struct glyph_matrix *, struct it *,
 21263                                struct glyph_row *);
 21264 
 21265 
 21266 /* Return the last row in MATRIX displaying text.  If row START is
 21267    non-null, start searching with that row.  IT gives the dimensions
 21268    of the display.  Value is null if matrix is empty; otherwise it is
 21269    a pointer to the row found.  */
 21270 
 21271 static struct glyph_row *
 21272 find_last_row_displaying_text (struct glyph_matrix *matrix, struct it *it,
 21273                                struct glyph_row *start)
 21274 {
 21275   struct glyph_row *row, *row_found;
 21276 
 21277   /* Set row_found to the last row in IT->w's current matrix
 21278      displaying text.  The loop looks funny but think of partially
 21279      visible lines.  */
 21280   row_found = NULL;
 21281   row = start ? start : MATRIX_FIRST_TEXT_ROW (matrix);
 21282   while (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21283     {
 21284       eassert (row->enabled_p);
 21285       row_found = row;
 21286       if (MATRIX_ROW_BOTTOM_Y (row) >= it->last_visible_y)
 21287         break;
 21288       ++row;
 21289     }
 21290 
 21291   return row_found;
 21292 }
 21293 
 21294 
 21295 /* Return the last row in the current matrix of W that is not affected
 21296    by changes at the start of current_buffer that occurred since W's
 21297    current matrix was built.  Value is null if no such row exists.
 21298 
 21299    BEG_UNCHANGED is the number of characters unchanged at the start of
 21300    current_buffer.  BEG + BEG_UNCHANGED is the buffer position of the
 21301    first changed character in current_buffer.  Characters at positions <
 21302    BEG + BEG_UNCHANGED are at the same buffer positions as they were
 21303    when the current matrix was built.  */
 21304 
 21305 static struct glyph_row *
 21306 find_last_unchanged_at_beg_row (struct window *w)
 21307 {
 21308   ptrdiff_t first_changed_pos = BEG + BEG_UNCHANGED;
 21309   struct glyph_row *row;
 21310   struct glyph_row *row_found = NULL;
 21311   int yb = window_text_bottom_y (w);
 21312 
 21313   /* Find the last row displaying unchanged text.  */
 21314   for (row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 21315        MATRIX_ROW_DISPLAYS_TEXT_P (row)
 21316          && MATRIX_ROW_START_CHARPOS (row) < first_changed_pos;
 21317        ++row)
 21318     {
 21319       if (/* If row ends before first_changed_pos, it is unchanged,
 21320              except in some case.  */
 21321           MATRIX_ROW_END_CHARPOS (row) <= first_changed_pos
 21322           /* When row ends in ZV and we write at ZV it is not
 21323              unchanged.  */
 21324           && !row->ends_at_zv_p
 21325           /* When first_changed_pos is the end of a continued line,
 21326              row is not unchanged because it may be no longer
 21327              continued.  */
 21328           && !(MATRIX_ROW_END_CHARPOS (row) == first_changed_pos
 21329                && (row->continued_p
 21330                    || row->exact_window_width_line_p))
 21331           /* If ROW->end is beyond ZV, then ROW->end is outdated and
 21332              needs to be recomputed, so don't consider this row as
 21333              unchanged.  This happens when the last line was
 21334              bidi-reordered and was killed immediately before this
 21335              redisplay cycle.  In that case, ROW->end stores the
 21336              buffer position of the first visual-order character of
 21337              the killed text, which is now beyond ZV.  */
 21338           && CHARPOS (row->end.pos) <= ZV)
 21339         row_found = row;
 21340 
 21341       /* Stop if last visible row.  */
 21342       if (MATRIX_ROW_BOTTOM_Y (row) >= yb)
 21343         break;
 21344     }
 21345 
 21346   return row_found;
 21347 }
 21348 
 21349 
 21350 /* Find the first glyph row in the current matrix of W that is not
 21351    affected by changes at the end of current_buffer since the
 21352    time W's current matrix was built.
 21353 
 21354    Return in *DELTA the number of chars by which buffer positions in
 21355    unchanged text at the end of current_buffer must be adjusted.
 21356 
 21357    Return in *DELTA_BYTES the corresponding number of bytes.
 21358 
 21359    Value is null if no such row exists, i.e. all rows are affected by
 21360    changes.  */
 21361 
 21362 static struct glyph_row *
 21363 find_first_unchanged_at_end_row (struct window *w,
 21364                                  ptrdiff_t *delta, ptrdiff_t *delta_bytes)
 21365 {
 21366   struct glyph_row *row;
 21367   struct glyph_row *row_found = NULL;
 21368 
 21369   *delta = *delta_bytes = 0;
 21370 
 21371   /* Display must not have been paused, otherwise the current matrix
 21372      is not up to date.  */
 21373   eassert (w->window_end_valid);
 21374 
 21375   /* A value of window_end_pos >= END_UNCHANGED means that the window
 21376      end is in the range of changed text.  If so, there is no
 21377      unchanged row at the end of W's current matrix.  */
 21378   if (w->window_end_pos >= END_UNCHANGED)
 21379     return NULL;
 21380 
 21381   /* Set row to the last row in W's current matrix displaying text.  */
 21382   row = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 21383 
 21384   /* If matrix is entirely empty, no unchanged row exists.  */
 21385   if (MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21386     {
 21387       /* The value of row is the last glyph row in the matrix having a
 21388          meaningful buffer position in it.  The end position of row
 21389          corresponds to window_end_pos.  This allows us to translate
 21390          buffer positions in the current matrix to current buffer
 21391          positions for characters not in changed text.  */
 21392       ptrdiff_t Z_old =
 21393         MATRIX_ROW_END_CHARPOS (row) + w->window_end_pos;
 21394       ptrdiff_t Z_BYTE_old =
 21395         MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
 21396       ptrdiff_t last_unchanged_pos, last_unchanged_pos_old;
 21397       struct glyph_row *first_text_row
 21398         = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 21399 
 21400       *delta = Z - Z_old;
 21401       *delta_bytes = Z_BYTE - Z_BYTE_old;
 21402 
 21403       /* Set last_unchanged_pos to the buffer position of the last
 21404          character in the buffer that has not been changed.  Z is the
 21405          index + 1 of the last character in current_buffer, i.e. by
 21406          subtracting END_UNCHANGED we get the index of the last
 21407          unchanged character, and we have to add BEG to get its buffer
 21408          position.  */
 21409       last_unchanged_pos = Z - END_UNCHANGED + BEG;
 21410       last_unchanged_pos_old = last_unchanged_pos - *delta;
 21411 
 21412       /* Search backward from ROW for a row displaying a line that
 21413          starts at a minimum position >= last_unchanged_pos_old.  */
 21414       for (; row > first_text_row; --row)
 21415         {
 21416           /* This used to abort, but it can happen.
 21417              It is ok to just stop the search instead here.  KFS.  */
 21418           if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
 21419             break;
 21420 
 21421           if (MATRIX_ROW_START_CHARPOS (row) >= last_unchanged_pos_old)
 21422             row_found = row;
 21423         }
 21424     }
 21425 
 21426   eassert (!row_found || MATRIX_ROW_DISPLAYS_TEXT_P (row_found));
 21427 
 21428   return row_found;
 21429 }
 21430 
 21431 
 21432 /* Make sure that glyph rows in the current matrix of window W
 21433    reference the same glyph memory as corresponding rows in the
 21434    frame's frame matrix.  This function is called after scrolling W's
 21435    current matrix on a terminal frame in try_window_id and
 21436    try_window_reusing_current_matrix.  */
 21437 
 21438 static void
 21439 sync_frame_with_window_matrix_rows (struct window *w)
 21440 {
 21441   struct frame *f = XFRAME (w->frame);
 21442   struct glyph_row *window_row, *window_row_end, *frame_row;
 21443 
 21444   /* Preconditions: W must be a leaf window and full-width.  Its frame
 21445      must have a frame matrix.  */
 21446   eassert (BUFFERP (w->contents));
 21447   eassert (WINDOW_FULL_WIDTH_P (w));
 21448   eassert (!FRAME_WINDOW_P (f));
 21449 
 21450   /* If W is a full-width window, glyph pointers in W's current matrix
 21451      have, by definition, to be the same as glyph pointers in the
 21452      corresponding frame matrix.  Note that frame matrices have no
 21453      marginal areas (see build_frame_matrix).  */
 21454   window_row = w->current_matrix->rows;
 21455   window_row_end = window_row + w->current_matrix->nrows;
 21456   frame_row = f->current_matrix->rows + WINDOW_TOP_EDGE_LINE (w);
 21457   while (window_row < window_row_end)
 21458     {
 21459       struct glyph *start = window_row->glyphs[LEFT_MARGIN_AREA];
 21460       struct glyph *end = window_row->glyphs[LAST_AREA];
 21461 
 21462       frame_row->glyphs[LEFT_MARGIN_AREA] = start;
 21463       frame_row->glyphs[TEXT_AREA] = start;
 21464       frame_row->glyphs[RIGHT_MARGIN_AREA] = end;
 21465       frame_row->glyphs[LAST_AREA] = end;
 21466 
 21467       /* Disable frame rows whose corresponding window rows have
 21468          been disabled in try_window_id.  */
 21469       if (!window_row->enabled_p)
 21470         frame_row->enabled_p = false;
 21471 
 21472       ++window_row, ++frame_row;
 21473     }
 21474 }
 21475 
 21476 
 21477 /* Find the glyph row in window W containing CHARPOS.  Consider all
 21478    rows between START and END (not inclusive).  END null means search
 21479    all rows to the end of the display area of W.  Value is the row
 21480    containing CHARPOS or null.  */
 21481 
 21482 struct glyph_row *
 21483 row_containing_pos (struct window *w, ptrdiff_t charpos,
 21484                     struct glyph_row *start, struct glyph_row *end, int dy)
 21485 {
 21486   struct glyph_row *row = start;
 21487   struct glyph_row *best_row = NULL;
 21488   ptrdiff_t mindif = BUF_ZV (XBUFFER (w->contents)) + 1;
 21489   int last_y;
 21490 
 21491   /* If we happen to start on a header-line or a tab-line, skip that.  */
 21492   if (row->tab_line_p)
 21493     ++row;
 21494   if (row->mode_line_p)
 21495     ++row;
 21496 
 21497   if ((end && row >= end) || !row->enabled_p)
 21498     return NULL;
 21499 
 21500   last_y = window_text_bottom_y (w) - dy;
 21501 
 21502   while (true)
 21503     {
 21504       /* Give up if we have gone too far.  */
 21505       if ((end && row >= end) || !row->enabled_p)
 21506         return NULL;
 21507       /* This formerly returned if they were equal.
 21508          I think that both quantities are of a "last plus one" type;
 21509          if so, when they are equal, the row is within the screen. -- rms.  */
 21510       if (MATRIX_ROW_BOTTOM_Y (row) > last_y)
 21511         return NULL;
 21512 
 21513       /* If it is in this row, return this row.  */
 21514       if (! (MATRIX_ROW_END_CHARPOS (row) < charpos
 21515              || (MATRIX_ROW_END_CHARPOS (row) == charpos
 21516                  /* The end position of a row equals the start
 21517                     position of the next row.  If CHARPOS is there, we
 21518                     would rather consider it displayed in the next
 21519                     line, except when this line ends in ZV.  */
 21520                  && !row_for_charpos_p (row, charpos)))
 21521           && charpos >= MATRIX_ROW_START_CHARPOS (row))
 21522         {
 21523           struct glyph *g;
 21524 
 21525           if (NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
 21526               || (!best_row && !row->continued_p))
 21527             return row;
 21528           /* In bidi-reordered rows, there could be several rows whose
 21529              edges surround CHARPOS, all of these rows belonging to
 21530              the same continued line.  We need to find the row which
 21531              fits CHARPOS the best.  */
 21532           for (g = row->glyphs[TEXT_AREA];
 21533                g < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 21534                g++)
 21535             {
 21536               if (!STRINGP (g->object))
 21537                 {
 21538                   if (g->charpos > 0 && eabs (g->charpos - charpos) < mindif)
 21539                     {
 21540                       mindif = eabs (g->charpos - charpos);
 21541                       best_row = row;
 21542                       /* Exact match always wins.  */
 21543                       if (mindif == 0)
 21544                         return best_row;
 21545                     }
 21546                 }
 21547             }
 21548         }
 21549       else if (best_row && !row->continued_p)
 21550         return best_row;
 21551       ++row;
 21552     }
 21553 }
 21554 
 21555 
 21556 /* Try to redisplay window W by reusing its existing display.  W's
 21557    current matrix must be up to date when this function is called,
 21558    i.e., window_end_valid must be true.
 21559 
 21560    Value is
 21561 
 21562    >= 1 if successful, i.e. display has been updated
 21563          specifically:
 21564          1 means the changes were in front of a newline that precedes
 21565            the window start, and the whole current matrix was reused
 21566          2 means the changes were after the last position displayed
 21567            in the window, and the whole current matrix was reused
 21568          3 means portions of the current matrix were reused, while
 21569            some of the screen lines were redrawn
 21570    -1   if redisplay with same window start is known not to succeed
 21571    0    if otherwise unsuccessful
 21572 
 21573    The following steps are performed:
 21574 
 21575    1. Find the last row in the current matrix of W that is not
 21576    affected by changes at the start of current_buffer.  If no such row
 21577    is found, give up.
 21578 
 21579    2. Find the first row in W's current matrix that is not affected by
 21580    changes at the end of current_buffer.  Maybe there is no such row.
 21581 
 21582    3. Display lines beginning with the row + 1 found in step 1 to the
 21583    row found in step 2 or, if step 2 didn't find a row, to the end of
 21584    the window.
 21585 
 21586    4. If cursor is not known to appear on the window, give up.
 21587 
 21588    5. If display stopped at the row found in step 2, scroll the
 21589    display and current matrix as needed.
 21590 
 21591    6. Maybe display some lines at the end of W, if we must.  This can
 21592    happen under various circumstances, like a partially visible line
 21593    becoming fully visible, or because newly displayed lines are displayed
 21594    in smaller font sizes.
 21595 
 21596    7. Update W's window end information.  */
 21597 
 21598 static int
 21599 try_window_id (struct window *w)
 21600 {
 21601   struct frame *f = XFRAME (w->frame);
 21602   struct glyph_matrix *current_matrix = w->current_matrix;
 21603   struct glyph_matrix *desired_matrix = w->desired_matrix;
 21604   struct glyph_row *last_unchanged_at_beg_row;
 21605   struct glyph_row *first_unchanged_at_end_row;
 21606   struct glyph_row *row;
 21607   struct glyph_row *bottom_row;
 21608   int bottom_vpos;
 21609   struct it it;
 21610   ptrdiff_t delta = 0, delta_bytes = 0, stop_pos;
 21611   int dvpos, dy;
 21612   struct text_pos start_pos;
 21613   struct run run;
 21614   int first_unchanged_at_end_vpos = 0;
 21615   struct glyph_row *last_text_row, *last_text_row_at_end;
 21616   struct text_pos start;
 21617   ptrdiff_t first_changed_charpos, last_changed_charpos;
 21618 
 21619 #ifdef GLYPH_DEBUG
 21620   if (inhibit_try_window_id)
 21621     return 0;
 21622 #endif
 21623 
 21624   /* This is handy for debugging.  */
 21625 #if false
 21626 #define GIVE_UP(X)                                              \
 21627   do {                                                          \
 21628     redisplay_trace ("try_window_id give up %d\n", X);          \
 21629     return 0;                                                   \
 21630   } while (false)
 21631 #else
 21632 #define GIVE_UP(X) return 0
 21633 #endif
 21634 
 21635   SET_TEXT_POS_FROM_MARKER (start, w->start);
 21636 
 21637   /* Don't use this for mini-windows because these can show
 21638      messages and mini-buffers, and we don't handle that here.  */
 21639   if (MINI_WINDOW_P (w))
 21640     GIVE_UP (1);
 21641 
 21642   /* This flag is used to prevent redisplay optimizations.  */
 21643   if (windows_or_buffers_changed || f->cursor_type_changed)
 21644     GIVE_UP (2);
 21645 
 21646   /* This function's optimizations cannot be used if overlays have
 21647      changed in the buffer displayed by the window, so give up if they
 21648      have.  */
 21649   if (w->last_overlay_modified != OVERLAY_MODIFF)
 21650     GIVE_UP (200);
 21651 
 21652   /* Verify that narrowing has not changed.
 21653      Also verify that we were not told to prevent redisplay optimizations.
 21654      It would be nice to further
 21655      reduce the number of cases where this prevents try_window_id.  */
 21656   if (current_buffer->clip_changed
 21657       || current_buffer->prevent_redisplay_optimizations_p)
 21658     GIVE_UP (3);
 21659 
 21660   /* Window must either use window-based redisplay or be full width.  */
 21661   if (!FRAME_WINDOW_P (f)
 21662       && (!FRAME_LINE_INS_DEL_OK (f)
 21663           || !WINDOW_FULL_WIDTH_P (w)))
 21664     GIVE_UP (4);
 21665 
 21666   /* Give up if point is known NOT to appear in W.  */
 21667   if (PT < CHARPOS (start))
 21668     GIVE_UP (5);
 21669 
 21670   /* Another way to prevent redisplay optimizations.  */
 21671   if (w->last_modified == 0)
 21672     GIVE_UP (6);
 21673 
 21674   /* Verify that window is not hscrolled.  */
 21675   if (w->hscroll != 0)
 21676     GIVE_UP (7);
 21677 
 21678   /* Verify that display wasn't paused.  */
 21679   if (!w->window_end_valid)
 21680     GIVE_UP (8);
 21681 
 21682   /* Likewise if highlighting trailing whitespace.  */
 21683   if (!NILP (Vshow_trailing_whitespace))
 21684     GIVE_UP (11);
 21685 
 21686   /* Can't use this if overlay arrow position and/or string have
 21687      changed.  */
 21688   if (overlay_arrows_changed_p (false))
 21689     GIVE_UP (12);
 21690 
 21691   /* When word-wrap is on, adding a space to the first word of a
 21692      wrapped line can change the wrap position, altering the line
 21693      above it.  It might be worthwhile to handle this more
 21694      intelligently, but for now just redisplay from scratch.  */
 21695   if (!NILP (BVAR (XBUFFER (w->contents), word_wrap)))
 21696     GIVE_UP (21);
 21697 
 21698   /* Under bidi reordering, adding or deleting a character in the
 21699      beginning of a paragraph, before the first strong directional
 21700      character, can change the base direction of the paragraph (unless
 21701      the buffer specifies a fixed paragraph direction), which will
 21702      require redisplaying the whole paragraph.  It might be worthwhile
 21703      to find the paragraph limits and widen the range of redisplayed
 21704      lines to that, but for now just give up this optimization and
 21705      redisplay from scratch.  */
 21706   if (!NILP (BVAR (XBUFFER (w->contents), bidi_display_reordering))
 21707       && NILP (BVAR (XBUFFER (w->contents), bidi_paragraph_direction)))
 21708     GIVE_UP (22);
 21709 
 21710   /* Give up if the buffer has line-spacing set, as Lisp-level changes
 21711      to that variable require thorough redisplay.  */
 21712   if (!NILP (BVAR (XBUFFER (w->contents), extra_line_spacing)))
 21713     GIVE_UP (23);
 21714 
 21715   /* Give up if display-line-numbers is in relative mode, or when the
 21716      current line's number needs to be displayed in a distinct face.  */
 21717   if (EQ (Vdisplay_line_numbers, Qrelative)
 21718       || EQ (Vdisplay_line_numbers, Qvisual)
 21719       || (!NILP (Vdisplay_line_numbers)
 21720           && NILP (Finternal_lisp_face_equal_p (Qline_number,
 21721                                                 Qline_number_current_line,
 21722                                                 w->frame))))
 21723     GIVE_UP (24);
 21724 
 21725   /* composition-break-at-point is incompatible with the optimizations
 21726      in this function, because we need to recompose characters when
 21727      point moves off their positions.  */
 21728   if (composition_break_at_point)
 21729     GIVE_UP (27);
 21730 
 21731   /* Make sure beg_unchanged and end_unchanged are up to date.  Do it
 21732      only if buffer has really changed.  The reason is that the gap is
 21733      initially at Z for freshly visited files.  The code below would
 21734      set end_unchanged to 0 in that case.  */
 21735   if (MODIFF > SAVE_MODIFF
 21736       /* This seems to happen sometimes after saving a buffer.  */
 21737       || BEG_UNCHANGED + END_UNCHANGED > Z_BYTE)
 21738     {
 21739       if (GPT - BEG < BEG_UNCHANGED)
 21740         BEG_UNCHANGED = GPT - BEG;
 21741       if (Z - GPT < END_UNCHANGED)
 21742         END_UNCHANGED = Z - GPT;
 21743     }
 21744 
 21745   /* The position of the first and last character that has been changed.  */
 21746   first_changed_charpos = BEG + BEG_UNCHANGED;
 21747   last_changed_charpos  = Z - END_UNCHANGED;
 21748 
 21749   /* If window starts after a line end, and the last change is in
 21750      front of that newline, then changes don't affect the display.
 21751      This case happens with stealth-fontification.  Note that although
 21752      the display is unchanged, glyph positions in the matrix have to
 21753      be adjusted, of course.  */
 21754   row = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 21755   if (MATRIX_ROW_DISPLAYS_TEXT_P (row)
 21756       && ((last_changed_charpos < CHARPOS (start)
 21757            && CHARPOS (start) == BEGV)
 21758           || (last_changed_charpos < CHARPOS (start) - 1
 21759               && FETCH_BYTE (BYTEPOS (start) - 1) == '\n')))
 21760     {
 21761       ptrdiff_t Z_old, Z_delta, Z_BYTE_old, Z_delta_bytes;
 21762       struct glyph_row *r0;
 21763 
 21764       /* Compute how many chars/bytes have been added to or removed
 21765          from the buffer.  */
 21766       Z_old = MATRIX_ROW_END_CHARPOS (row) + w->window_end_pos;
 21767       Z_BYTE_old = MATRIX_ROW_END_BYTEPOS (row) + w->window_end_bytepos;
 21768       Z_delta = Z - Z_old;
 21769       Z_delta_bytes = Z_BYTE - Z_BYTE_old;
 21770 
 21771       /* Give up if PT is not in the window.  Note that it already has
 21772          been checked at the start of try_window_id that PT is not in
 21773          front of the window start.  */
 21774       if (PT >= MATRIX_ROW_END_CHARPOS (row) + Z_delta)
 21775         GIVE_UP (13);
 21776 
 21777       /* If window start is unchanged, we can reuse the whole matrix
 21778          as is, after adjusting glyph positions.  No need to compute
 21779          the window end again, since its offset from Z hasn't changed.  */
 21780       r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
 21781       if (CHARPOS (start) == MATRIX_ROW_START_CHARPOS (r0) + Z_delta
 21782           && BYTEPOS (start) == MATRIX_ROW_START_BYTEPOS (r0) + Z_delta_bytes
 21783           /* PT must not be in a partially visible line.  */
 21784           && !(PT >= MATRIX_ROW_START_CHARPOS (row) + Z_delta
 21785                && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
 21786         {
 21787           /* Adjust positions in the glyph matrix.  */
 21788           if (Z_delta || Z_delta_bytes)
 21789             {
 21790               struct glyph_row *r1
 21791                 = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
 21792               increment_matrix_positions (w->current_matrix,
 21793                                           MATRIX_ROW_VPOS (r0, current_matrix),
 21794                                           MATRIX_ROW_VPOS (r1, current_matrix),
 21795                                           Z_delta, Z_delta_bytes);
 21796             }
 21797 
 21798           /* Set the cursor.  */
 21799           row = row_containing_pos (w, PT, r0, NULL, 0);
 21800           if (row)
 21801             set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
 21802           return 1;
 21803         }
 21804     }
 21805 
 21806   /* Handle the case that changes are all below what is displayed in
 21807      the window, and that PT is in the window.  This shortcut cannot
 21808      be taken if ZV is visible in the window, and text has been added
 21809      there that is visible in the window.  */
 21810   if (first_changed_charpos >= MATRIX_ROW_END_CHARPOS (row)
 21811       /* ZV is not visible in the window, or there are no
 21812          changes at ZV, actually.  */
 21813       && (current_matrix->zv > MATRIX_ROW_END_CHARPOS (row)
 21814           || first_changed_charpos == last_changed_charpos))
 21815     {
 21816       struct glyph_row *r0;
 21817 
 21818       /* Give up if PT is not in the window.  Note that it already has
 21819          been checked at the start of try_window_id that PT is not in
 21820          front of the window start.  */
 21821       if (PT >= MATRIX_ROW_END_CHARPOS (row))
 21822         GIVE_UP (14);
 21823 
 21824       /* If window start is unchanged, we can reuse the whole matrix
 21825          as is, without changing glyph positions since no text has
 21826          been added/removed in front of the window end.  */
 21827       r0 = MATRIX_FIRST_TEXT_ROW (current_matrix);
 21828       if (TEXT_POS_EQUAL_P (start, r0->minpos)
 21829           /* PT must not be in a partially visible line.  */
 21830           && !(PT >= MATRIX_ROW_START_CHARPOS (row)
 21831                && MATRIX_ROW_BOTTOM_Y (row) > window_text_bottom_y (w)))
 21832         {
 21833           /* We have to compute the window end anew since text
 21834              could have been added/removed after it.  */
 21835           w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
 21836           w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
 21837 
 21838           /* Set the cursor.  */
 21839           row = row_containing_pos (w, PT, r0, NULL, 0);
 21840           if (row)
 21841             set_cursor_from_row (w, row, current_matrix, 0, 0, 0, 0);
 21842           return 2;
 21843         }
 21844     }
 21845 
 21846   /* Give up if window start is in the changed area.
 21847 
 21848      The condition used to read
 21849 
 21850      (BEG_UNCHANGED + END_UNCHANGED != Z - BEG && ...)
 21851 
 21852      but why that was tested escapes me at the moment.  */
 21853   if (CHARPOS (start) >= first_changed_charpos
 21854       && CHARPOS (start) <= last_changed_charpos)
 21855     GIVE_UP (15);
 21856 
 21857   /* Check that window start agrees with the start of the first glyph
 21858      row in its current matrix.  Check this after we know the window
 21859      start is not in changed text, otherwise positions would not be
 21860      comparable.  */
 21861   row = MATRIX_FIRST_TEXT_ROW (current_matrix);
 21862   if (!TEXT_POS_EQUAL_P (start, row->minpos))
 21863     GIVE_UP (16);
 21864 
 21865   /* Give up if the window ends in strings.  Overlay strings
 21866      at the end are difficult to handle, so don't try.  */
 21867   row = MATRIX_ROW (current_matrix, w->window_end_vpos);
 21868   if (MATRIX_ROW_START_CHARPOS (row) == MATRIX_ROW_END_CHARPOS (row))
 21869     GIVE_UP (20);
 21870 
 21871   /* Can't let scroll_run_hook below run on w32 GUI frames when
 21872      position of point is indicated by the system caret, because
 21873      scrolling the display will then "copy" the pixels used by the
 21874      caret.  */
 21875 #ifdef HAVE_NTGUI
 21876   if (FRAME_W32_P (f) && w32_use_visible_system_caret)
 21877     GIVE_UP (25);
 21878 #endif
 21879 
 21880   /* Compute the position at which we have to start displaying new
 21881      lines.  Some of the lines at the top of the window might be
 21882      reusable because they are not displaying changed text.  Find the
 21883      last row in W's current matrix not affected by changes at the
 21884      start of current_buffer.  Value is null if changes start in the
 21885      first line of window.  */
 21886   last_unchanged_at_beg_row = find_last_unchanged_at_beg_row (w);
 21887   if (last_unchanged_at_beg_row)
 21888     {
 21889       /* Avoid starting to display in the middle of a character, a TAB
 21890          for instance.  This is easier than to set up the iterator
 21891          exactly, and it's not a frequent case, so the additional
 21892          effort wouldn't really pay off.  */
 21893       while ((MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row)
 21894               || last_unchanged_at_beg_row->ends_in_newline_from_string_p)
 21895              && last_unchanged_at_beg_row > w->current_matrix->rows)
 21896         --last_unchanged_at_beg_row;
 21897 
 21898       if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (last_unchanged_at_beg_row))
 21899         GIVE_UP (17);
 21900 
 21901       if (! init_to_row_end (&it, w, last_unchanged_at_beg_row))
 21902         GIVE_UP (18);
 21903       /* Give up if the row starts with a display property that draws
 21904          on the fringes, since that could prevent correct display of
 21905          line-prefix and wrap-prefix.  */
 21906       if (it.sp > 1
 21907           && it.method == GET_FROM_IMAGE && it.image_id == -1)
 21908         GIVE_UP (26);
 21909       start_pos = it.current.pos;
 21910 
 21911       /* Start displaying new lines in the desired matrix at the same
 21912          vpos we would use in the current matrix, i.e. below
 21913          last_unchanged_at_beg_row.  */
 21914       it.vpos = 1 + MATRIX_ROW_VPOS (last_unchanged_at_beg_row,
 21915                                      current_matrix);
 21916       it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
 21917       it.current_y = MATRIX_ROW_BOTTOM_Y (last_unchanged_at_beg_row);
 21918 
 21919       eassert (it.hpos == 0 && it.current_x == 0);
 21920     }
 21921   else
 21922     {
 21923       /* There are no reusable lines at the start of the window.
 21924          Start displaying in the first text line.  */
 21925       start_display (&it, w, start);
 21926       it.vpos = it.first_vpos;
 21927       start_pos = it.current.pos;
 21928     }
 21929 
 21930   /* Find the first row that is not affected by changes at the end of
 21931      the buffer.  Value will be null if there is no unchanged row, in
 21932      which case we must redisplay to the end of the window.  delta
 21933      will be set to the value by which buffer positions beginning with
 21934      first_unchanged_at_end_row have to be adjusted due to text
 21935      changes.  */
 21936   first_unchanged_at_end_row
 21937     = find_first_unchanged_at_end_row (w, &delta, &delta_bytes);
 21938   IF_DEBUG (debug_delta = delta);
 21939   IF_DEBUG (debug_delta_bytes = delta_bytes);
 21940 
 21941   /* Set stop_pos to the buffer position up to which we will have to
 21942      display new lines.  If first_unchanged_at_end_row != NULL, this
 21943      is the buffer position of the start of the line displayed in that
 21944      row.  For first_unchanged_at_end_row == NULL, use 0 to indicate
 21945      that we don't stop at a buffer position.  */
 21946   stop_pos = 0;
 21947   if (first_unchanged_at_end_row)
 21948     {
 21949       eassert (last_unchanged_at_beg_row == NULL
 21950                || first_unchanged_at_end_row >= last_unchanged_at_beg_row);
 21951 
 21952       /* If this is a continuation line, move forward to the next one
 21953          that isn't.  Changes in lines above affect this line.
 21954          Caution: this may move first_unchanged_at_end_row to a row
 21955          not displaying text.  */
 21956       while (MATRIX_ROW_CONTINUATION_LINE_P (first_unchanged_at_end_row)
 21957              && MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
 21958              && (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
 21959                  < it.last_visible_y))
 21960         ++first_unchanged_at_end_row;
 21961 
 21962       if (!MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row)
 21963           || (MATRIX_ROW_BOTTOM_Y (first_unchanged_at_end_row)
 21964               >= it.last_visible_y))
 21965         first_unchanged_at_end_row = NULL;
 21966       else
 21967         {
 21968           stop_pos = (MATRIX_ROW_START_CHARPOS (first_unchanged_at_end_row)
 21969                       + delta);
 21970           first_unchanged_at_end_vpos
 21971             = MATRIX_ROW_VPOS (first_unchanged_at_end_row, current_matrix);
 21972           eassert (stop_pos >= Z - END_UNCHANGED);
 21973         }
 21974     }
 21975   else if (last_unchanged_at_beg_row == NULL)
 21976     GIVE_UP (19);
 21977 
 21978 
 21979 #ifdef GLYPH_DEBUG
 21980 
 21981   /* Either there is no unchanged row at the end, or the one we have
 21982      now displays text.  This is a necessary condition for the window
 21983      end pos calculation at the end of this function.  */
 21984   eassert (first_unchanged_at_end_row == NULL
 21985            || MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row));
 21986 
 21987   debug_last_unchanged_at_beg_vpos
 21988     = (last_unchanged_at_beg_row
 21989        ? MATRIX_ROW_VPOS (last_unchanged_at_beg_row, current_matrix)
 21990        : -1);
 21991   debug_first_unchanged_at_end_vpos = first_unchanged_at_end_vpos;
 21992 
 21993 #endif /* GLYPH_DEBUG */
 21994 
 21995 
 21996   /* Display new lines.  Set last_text_row to the last new line
 21997      displayed which has text on it, i.e. might end up as being the
 21998      line where the window_end_vpos is.  */
 21999   w->cursor.vpos = -1;
 22000   last_text_row = NULL;
 22001   overlay_arrow_seen = false;
 22002   if (it.current_y < it.last_visible_y
 22003       && !f->fonts_changed
 22004       && (first_unchanged_at_end_row == NULL
 22005           || IT_CHARPOS (it) < stop_pos))
 22006     it.glyph_row->reversed_p = false;
 22007   while (it.current_y < it.last_visible_y
 22008          && !f->fonts_changed
 22009          && (first_unchanged_at_end_row == NULL
 22010              || IT_CHARPOS (it) < stop_pos))
 22011     {
 22012       if (display_line (&it, -1))
 22013         last_text_row = it.glyph_row - 1;
 22014     }
 22015 
 22016   if (f->fonts_changed)
 22017     return -1;
 22018 
 22019   /* The redisplay iterations in display_line above could have
 22020      triggered font-lock, which could have done something that
 22021      invalidates IT->w window's end-point information, on which we
 22022      rely below.  E.g., one package, which will remain unnamed, used
 22023      to install a font-lock-fontify-region-function that called
 22024      bury-buffer, whose side effect is to switch the buffer displayed
 22025      by IT->w, and that predictably resets IT->w's window_end_valid
 22026      flag, which we already tested at the entry to this function.
 22027      Amply punish such packages/modes by giving up on this
 22028      optimization in those cases.  */
 22029   if (!w->window_end_valid)
 22030     {
 22031       clear_glyph_matrix (w->desired_matrix);
 22032       return -1;
 22033     }
 22034 
 22035   /* Compute differences in buffer positions, y-positions etc.  for
 22036      lines reused at the bottom of the window.  Compute what we can
 22037      scroll.  */
 22038   if (first_unchanged_at_end_row
 22039       /* No lines reused because we displayed everything up to the
 22040          bottom of the window.  */
 22041       && it.current_y < it.last_visible_y)
 22042     {
 22043       dvpos = (it.vpos
 22044                - MATRIX_ROW_VPOS (first_unchanged_at_end_row,
 22045                                   current_matrix));
 22046       dy = it.current_y - first_unchanged_at_end_row->y;
 22047       run.current_y = first_unchanged_at_end_row->y;
 22048       run.desired_y = run.current_y + dy;
 22049       run.height = it.last_visible_y - max (run.current_y, run.desired_y);
 22050     }
 22051   else
 22052     {
 22053       delta = delta_bytes = dvpos = dy
 22054         = run.current_y = run.desired_y = run.height = 0;
 22055       first_unchanged_at_end_row = NULL;
 22056     }
 22057   IF_DEBUG ((debug_dvpos = dvpos, debug_dy = dy));
 22058 
 22059 
 22060   /* Find the cursor if not already found.  We have to decide whether
 22061      PT will appear on this window (it sometimes doesn't, but this is
 22062      not a very frequent case.)  This decision has to be made before
 22063      the current matrix is altered.  A value of cursor.vpos < 0 means
 22064      that PT is either in one of the lines beginning at
 22065      first_unchanged_at_end_row or below the window.  Don't care for
 22066      lines that might be displayed later at the window end; as
 22067      mentioned, this is not a frequent case.  */
 22068   if (w->cursor.vpos < 0)
 22069     {
 22070       /* Cursor in unchanged rows at the top?  */
 22071       if (PT < CHARPOS (start_pos)
 22072           && last_unchanged_at_beg_row)
 22073         {
 22074           row = row_containing_pos (w, PT,
 22075                                     MATRIX_FIRST_TEXT_ROW (w->current_matrix),
 22076                                     last_unchanged_at_beg_row + 1, 0);
 22077           if (row)
 22078             set_cursor_from_row (w, row, w->current_matrix, 0, 0, 0, 0);
 22079         }
 22080 
 22081       /* Start from first_unchanged_at_end_row looking for PT.  */
 22082       else if (first_unchanged_at_end_row)
 22083         {
 22084           row = row_containing_pos (w, PT - delta,
 22085                                     first_unchanged_at_end_row, NULL, 0);
 22086           if (row)
 22087             set_cursor_from_row (w, row, w->current_matrix, delta,
 22088                                  delta_bytes, dy, dvpos);
 22089         }
 22090 
 22091       /* Give up if cursor was not found.  */
 22092       if (w->cursor.vpos < 0)
 22093         {
 22094           clear_glyph_matrix (w->desired_matrix);
 22095           return -1;
 22096         }
 22097     }
 22098 
 22099   /* Don't let the cursor end in the scroll margins.  */
 22100   {
 22101     int top_scroll_margin = window_scroll_margin (w, MARGIN_IN_PIXELS);
 22102     int bot_scroll_margin = top_scroll_margin;
 22103     int cursor_height = MATRIX_ROW (w->desired_matrix, w->cursor.vpos)->height;
 22104 
 22105     if (window_wants_header_line (w))
 22106       top_scroll_margin += CURRENT_HEADER_LINE_HEIGHT (w);
 22107     if (window_wants_tab_line (w))
 22108       top_scroll_margin += CURRENT_TAB_LINE_HEIGHT (w);
 22109 
 22110     if ((w->cursor.y < top_scroll_margin
 22111          && CHARPOS (start) > BEGV)
 22112         /* Old redisplay didn't take scroll margin into account at the bottom,
 22113            but then global-hl-line-mode doesn't scroll.  KFS 2004-06-14 */
 22114         || (w->cursor.y
 22115             + (cursor_row_fully_visible_p (w, false, true, true)
 22116                ? 1
 22117                : cursor_height + bot_scroll_margin)) > it.last_visible_y)
 22118       {
 22119         w->cursor.vpos = -1;
 22120         clear_glyph_matrix (w->desired_matrix);
 22121         return -1;
 22122       }
 22123   }
 22124 
 22125   /* Scroll the display.  Do it before changing the current matrix so
 22126      that xterm.c doesn't get confused about where the cursor glyph is
 22127      found.  */
 22128   if (dy && run.height)
 22129     {
 22130       update_begin (f);
 22131 
 22132       if (FRAME_WINDOW_P (f))
 22133         {
 22134 #ifdef HAVE_WINDOW_SYSTEM
 22135           gui_update_window_begin (w);
 22136           FRAME_RIF (f)->clear_window_mouse_face (w);
 22137           FRAME_RIF (f)->scroll_run_hook (w, &run);
 22138           gui_update_window_end (w, false, false);
 22139 #endif
 22140         }
 22141       else
 22142         {
 22143           /* Terminal frame.  In this case, dvpos gives the number of
 22144              lines to scroll by; dvpos < 0 means scroll up.  */
 22145           int from_vpos
 22146             = MATRIX_ROW_VPOS (first_unchanged_at_end_row, w->current_matrix);
 22147           int from = WINDOW_TOP_EDGE_LINE (w) + from_vpos;
 22148           int end = (WINDOW_TOP_EDGE_LINE (w)
 22149                      + window_wants_tab_line (w)
 22150                      + window_wants_header_line (w)
 22151                      + window_internal_height (w));
 22152 
 22153           gui_clear_window_mouse_face (w);
 22154 
 22155           /* Perform the operation on the screen.  */
 22156           if (dvpos > 0)
 22157             {
 22158               /* Scroll last_unchanged_at_beg_row to the end of the
 22159                  window down dvpos lines.  */
 22160               set_terminal_window (f, end);
 22161 
 22162               /* On dumb terminals delete dvpos lines at the end
 22163                  before inserting dvpos empty lines.  */
 22164               if (!FRAME_SCROLL_REGION_OK (f))
 22165                 ins_del_lines (f, end - dvpos, -dvpos);
 22166 
 22167               /* Insert dvpos empty lines in front of
 22168                  last_unchanged_at_beg_row.  */
 22169               ins_del_lines (f, from, dvpos);
 22170             }
 22171           else if (dvpos < 0)
 22172             {
 22173               /* Scroll up last_unchanged_at_beg_vpos to the end of
 22174                  the window to last_unchanged_at_beg_vpos - |dvpos|.  */
 22175               set_terminal_window (f, end);
 22176 
 22177               /* Delete dvpos lines in front of
 22178                  last_unchanged_at_beg_vpos.  ins_del_lines will set
 22179                  the cursor to the given vpos and emit |dvpos| delete
 22180                  line sequences.  */
 22181               ins_del_lines (f, from + dvpos, dvpos);
 22182 
 22183               /* On a dumb terminal insert dvpos empty lines at the
 22184                  end.  */
 22185               if (!FRAME_SCROLL_REGION_OK (f))
 22186                 ins_del_lines (f, end + dvpos, -dvpos);
 22187             }
 22188 
 22189           set_terminal_window (f, 0);
 22190         }
 22191 
 22192       update_end (f);
 22193     }
 22194 
 22195   /* Shift reused rows of the current matrix to the right position.
 22196      BOTTOM_ROW is the last + 1 row in the current matrix reserved for
 22197      text.  */
 22198   bottom_row = MATRIX_BOTTOM_TEXT_ROW (current_matrix, w);
 22199   bottom_vpos = MATRIX_ROW_VPOS (bottom_row, current_matrix);
 22200   if (dvpos < 0)
 22201     {
 22202       rotate_matrix (current_matrix, first_unchanged_at_end_vpos + dvpos,
 22203                      bottom_vpos, dvpos);
 22204       clear_glyph_matrix_rows (current_matrix, bottom_vpos + dvpos,
 22205                                bottom_vpos);
 22206     }
 22207   else if (dvpos > 0)
 22208     {
 22209       rotate_matrix (current_matrix, first_unchanged_at_end_vpos,
 22210                      bottom_vpos, dvpos);
 22211       clear_glyph_matrix_rows (current_matrix, first_unchanged_at_end_vpos,
 22212                                first_unchanged_at_end_vpos + dvpos);
 22213     }
 22214 
 22215   /* For frame-based redisplay, make sure that current frame and window
 22216      matrix are in sync with respect to glyph memory.  */
 22217   if (!FRAME_WINDOW_P (f))
 22218     sync_frame_with_window_matrix_rows (w);
 22219 
 22220   /* Adjust buffer positions in reused rows.  */
 22221   if (delta || delta_bytes)
 22222     increment_matrix_positions (current_matrix,
 22223                                 first_unchanged_at_end_vpos + dvpos,
 22224                                 bottom_vpos, delta, delta_bytes);
 22225 
 22226   /* Adjust Y positions.  */
 22227   if (dy)
 22228     shift_glyph_matrix (w, current_matrix,
 22229                         first_unchanged_at_end_vpos + dvpos,
 22230                         bottom_vpos, dy);
 22231 
 22232   if (first_unchanged_at_end_row)
 22233     {
 22234       first_unchanged_at_end_row += dvpos;
 22235       if (first_unchanged_at_end_row->y >= it.last_visible_y
 22236           || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row))
 22237         first_unchanged_at_end_row = NULL;
 22238     }
 22239 
 22240   /* If scrolling up, there may be some lines to display at the end of
 22241      the window.  */
 22242   last_text_row_at_end = NULL;
 22243   if (dy < 0)
 22244     {
 22245       /* Scrolling up can leave for example a partially visible line
 22246          at the end of the window to be redisplayed.  */
 22247       /* Set last_row to the glyph row in the current matrix where the
 22248          window end line is found.  It has been moved up or down in
 22249          the matrix by dvpos.  */
 22250       int last_vpos = w->window_end_vpos + dvpos;
 22251       struct glyph_row *last_row = MATRIX_ROW (current_matrix, last_vpos);
 22252 
 22253       /* If last_row is the window end line, it should display text.  */
 22254       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (last_row));
 22255 
 22256       /* If window end line was partially visible before, begin
 22257          displaying at that line.  Otherwise begin displaying with the
 22258          line following it.  */
 22259       if (MATRIX_ROW_BOTTOM_Y (last_row) - dy >= it.last_visible_y)
 22260         {
 22261           init_to_row_start (&it, w, last_row);
 22262           it.vpos = last_vpos;
 22263           it.current_y = last_row->y;
 22264         }
 22265       else
 22266         {
 22267           init_to_row_end (&it, w, last_row);
 22268           it.vpos = 1 + last_vpos;
 22269           it.current_y = MATRIX_ROW_BOTTOM_Y (last_row);
 22270           ++last_row;
 22271         }
 22272 
 22273       /* We may start in a continuation line.  If so, we have to
 22274          get the right continuation_lines_width and current_x.  */
 22275       it.continuation_lines_width = last_row->continuation_lines_width;
 22276       it.hpos = it.current_x = 0;
 22277 
 22278       /* Display the rest of the lines at the window end.  */
 22279       it.glyph_row = MATRIX_ROW (desired_matrix, it.vpos);
 22280       while (it.current_y < it.last_visible_y && !f->fonts_changed)
 22281         {
 22282           /* Is it always sure that the display agrees with lines in
 22283              the current matrix?  I don't think so, so we mark rows
 22284              displayed invalid in the current matrix by setting their
 22285              enabled_p flag to false.  */
 22286           SET_MATRIX_ROW_ENABLED_P (w->current_matrix, it.vpos, false);
 22287           if (display_line (&it, w->cursor.vpos))
 22288             last_text_row_at_end = it.glyph_row - 1;
 22289         }
 22290     }
 22291 
 22292   /* Update window_end_pos and window_end_vpos.  */
 22293   if (first_unchanged_at_end_row && !last_text_row_at_end)
 22294     {
 22295       /* Window end line if one of the preserved rows from the current
 22296          matrix.  Set row to the last row displaying text in current
 22297          matrix starting at first_unchanged_at_end_row, after
 22298          scrolling.  */
 22299       eassert (MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row));
 22300       row = find_last_row_displaying_text (w->current_matrix, &it,
 22301                                            first_unchanged_at_end_row);
 22302       eassume (row && MATRIX_ROW_DISPLAYS_TEXT_P (row));
 22303       adjust_window_ends (w, row, true);
 22304       eassert (w->window_end_bytepos >= 0);
 22305       IF_DEBUG (debug_method_add (w, "A"));
 22306     }
 22307   else if (last_text_row_at_end)
 22308     {
 22309       adjust_window_ends (w, last_text_row_at_end, false);
 22310       eassert (w->window_end_bytepos >= 0);
 22311       IF_DEBUG (debug_method_add (w, "B"));
 22312     }
 22313   else if (last_text_row)
 22314     {
 22315       /* We have displayed either to the end of the window or at the
 22316          end of the window, i.e. the last row with text is to be found
 22317          in the desired matrix.  */
 22318       adjust_window_ends (w, last_text_row, false);
 22319       eassert (w->window_end_bytepos >= 0);
 22320     }
 22321   else if (first_unchanged_at_end_row == NULL
 22322            && last_text_row == NULL
 22323            && last_text_row_at_end == NULL)
 22324     {
 22325       /* Displayed to end of window, but no line containing text was
 22326          displayed.  Lines were deleted at the end of the window.  */
 22327       int first_vpos = window_wants_tab_line (w) + window_wants_header_line (w);
 22328       int vpos = w->window_end_vpos;
 22329       struct glyph_row *current_row = current_matrix->rows + vpos;
 22330       struct glyph_row *desired_row = desired_matrix->rows + vpos;
 22331 
 22332       for (row = NULL; !row; --vpos, --current_row, --desired_row)
 22333         {
 22334           eassert (first_vpos <= vpos);
 22335           if (desired_row->enabled_p)
 22336             {
 22337               if (MATRIX_ROW_DISPLAYS_TEXT_P (desired_row))
 22338                 row = desired_row;
 22339             }
 22340           else if (MATRIX_ROW_DISPLAYS_TEXT_P (current_row))
 22341             row  = current_row;
 22342         }
 22343 
 22344       w->window_end_vpos = vpos + 1;
 22345       w->window_end_pos = Z - MATRIX_ROW_END_CHARPOS (row);
 22346       w->window_end_bytepos = Z_BYTE - MATRIX_ROW_END_BYTEPOS (row);
 22347       eassert (w->window_end_bytepos >= 0);
 22348       IF_DEBUG (debug_method_add (w, "C"));
 22349     }
 22350   else
 22351     emacs_abort ();
 22352 
 22353   IF_DEBUG ((debug_end_pos = w->window_end_pos,
 22354              debug_end_vpos = w->window_end_vpos));
 22355 
 22356   /* Record that display has not been completed.  */
 22357   w->window_end_valid = false;
 22358   w->desired_matrix->no_scrolling_p = true;
 22359   return 3;
 22360 
 22361 #undef GIVE_UP
 22362 }
 22363 
 22364 
 22365 
 22366 /***********************************************************************
 22367                         More debugging support
 22368  ***********************************************************************/
 22369 
 22370 #ifdef GLYPH_DEBUG
 22371 
 22372 void dump_glyph_row (struct glyph_row *, int, int) EXTERNALLY_VISIBLE;
 22373 void dump_glyph_matrix (struct glyph_matrix *, int) EXTERNALLY_VISIBLE;
 22374 void dump_glyph (struct glyph_row *, struct glyph *, int) EXTERNALLY_VISIBLE;
 22375 
 22376 
 22377 /* Dump the contents of glyph matrix MATRIX on stderr.
 22378 
 22379    GLYPHS 0 means don't show glyph contents.
 22380    GLYPHS 1 means show glyphs in short form
 22381    GLYPHS > 1 means show glyphs in long form.  */
 22382 
 22383 void
 22384 dump_glyph_matrix (struct glyph_matrix *matrix, int glyphs)
 22385 {
 22386   int i;
 22387   for (i = 0; i < matrix->nrows; ++i)
 22388     dump_glyph_row (MATRIX_ROW (matrix, i), i, glyphs);
 22389 }
 22390 
 22391 
 22392 /* Dump contents of glyph GLYPH to stderr.  ROW and AREA are
 22393    the glyph row and area where the glyph comes from.  */
 22394 
 22395 void
 22396 dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
 22397 {
 22398   if (glyph->type == CHAR_GLYPH
 22399       || glyph->type == GLYPHLESS_GLYPH)
 22400     {
 22401       fprintf (stderr,
 22402                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
 22403                glyph - row->glyphs[TEXT_AREA],
 22404                (glyph->type == CHAR_GLYPH
 22405                 ? 'C'
 22406                 : 'G'),
 22407                glyph->charpos,
 22408                (BUFFERP (glyph->object)
 22409                 ? 'B'
 22410                 : (STRINGP (glyph->object)
 22411                    ? 'S'
 22412                    : (NILP (glyph->object)
 22413                       ? '0'
 22414                       : '-'))),
 22415                glyph->pixel_width,
 22416                glyph->u.ch,
 22417                (glyph->u.ch < 0x80 && glyph->u.ch >= ' '
 22418                 ? (int) glyph->u.ch
 22419                 : '.'),
 22420                glyph->face_id,
 22421                glyph->left_box_line_p,
 22422                glyph->right_box_line_p);
 22423     }
 22424   else if (glyph->type == STRETCH_GLYPH)
 22425     {
 22426       fprintf (stderr,
 22427                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
 22428                glyph - row->glyphs[TEXT_AREA],
 22429                'S',
 22430                glyph->charpos,
 22431                (BUFFERP (glyph->object)
 22432                 ? 'B'
 22433                 : (STRINGP (glyph->object)
 22434                    ? 'S'
 22435                    : (NILP (glyph->object)
 22436                       ? '0'
 22437                       : '-'))),
 22438                glyph->pixel_width,
 22439                0u,
 22440                ' ',
 22441                glyph->face_id,
 22442                glyph->left_box_line_p,
 22443                glyph->right_box_line_p);
 22444     }
 22445   else if (glyph->type == IMAGE_GLYPH)
 22446     {
 22447       fprintf (stderr,
 22448                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
 22449                glyph - row->glyphs[TEXT_AREA],
 22450                'I',
 22451                glyph->charpos,
 22452                (BUFFERP (glyph->object)
 22453                 ? 'B'
 22454                 : (STRINGP (glyph->object)
 22455                    ? 'S'
 22456                    : (NILP (glyph->object)
 22457                       ? '0'
 22458                       : '-'))),
 22459                glyph->pixel_width,
 22460                (unsigned int) glyph->u.img_id,
 22461                '.',
 22462                glyph->face_id,
 22463                glyph->left_box_line_p,
 22464                glyph->right_box_line_p);
 22465     }
 22466   else if (glyph->type == COMPOSITE_GLYPH)
 22467     {
 22468       fprintf (stderr,
 22469                "  %5"pD"d     %c %9"pD"d   %c %3d 0x%06x",
 22470                glyph - row->glyphs[TEXT_AREA],
 22471                '+',
 22472                glyph->charpos,
 22473                (BUFFERP (glyph->object)
 22474                 ? 'B'
 22475                 : (STRINGP (glyph->object)
 22476                    ? 'S'
 22477                    : (NILP (glyph->object)
 22478                       ? '0'
 22479                       : '-'))),
 22480                glyph->pixel_width,
 22481                (unsigned int) glyph->u.cmp.id);
 22482       if (glyph->u.cmp.automatic)
 22483         fprintf (stderr,
 22484                  "[%d-%d]",
 22485                  glyph->slice.cmp.from, glyph->slice.cmp.to);
 22486       fprintf (stderr, " . %4d %1.1d%1.1d\n",
 22487                glyph->face_id,
 22488                glyph->left_box_line_p,
 22489                glyph->right_box_line_p);
 22490     }
 22491   else if (glyph->type == XWIDGET_GLYPH)
 22492     {
 22493 #ifndef HAVE_XWIDGETS
 22494       eassume (false);
 22495 #else
 22496       fprintf (stderr,
 22497                "  %5td %4c %6td %c %3d %7p %c %4d %1.1d%1.1d\n",
 22498                glyph - row->glyphs[TEXT_AREA],
 22499                'X',
 22500                glyph->charpos,
 22501                (BUFFERP (glyph->object)
 22502                 ? 'B'
 22503                 : (STRINGP (glyph->object)
 22504                    ? 'S'
 22505                    : '-')),
 22506                glyph->pixel_width,
 22507                glyph->u.xwidget,
 22508                '.',
 22509                glyph->face_id,
 22510                glyph->left_box_line_p,
 22511                glyph->right_box_line_p);
 22512 #endif
 22513     }
 22514 }
 22515 
 22516 
 22517 /* Dump the contents of glyph row at VPOS in MATRIX to stderr.
 22518    GLYPHS 0 means don't show glyph contents.
 22519    GLYPHS 1 means show glyphs in short form
 22520    GLYPHS > 1 means show glyphs in long form.  */
 22521 
 22522 void
 22523 dump_glyph_row (struct glyph_row *row, int vpos, int glyphs)
 22524 {
 22525   if (glyphs != 1)
 22526     {
 22527       fputs (("Row     Start       End Used oE><\\CTZFesm     X    Y    W    H    V    A    P\n"
 22528               "==============================================================================\n"),
 22529              stderr);
 22530       fprintf (stderr, "%3d %9"pD"d %9"pD"d %4d %1.1d%1.1d%1.1d%1.1d\
 22531 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d  %4d %4d %4d %4d %4d %4d %4d\n",
 22532                vpos,
 22533                MATRIX_ROW_START_CHARPOS (row),
 22534                MATRIX_ROW_END_CHARPOS (row),
 22535                row->used[TEXT_AREA],
 22536                row->contains_overlapping_glyphs_p,
 22537                row->enabled_p,
 22538                row->truncated_on_left_p,
 22539                row->truncated_on_right_p,
 22540                row->continued_p,
 22541                MATRIX_ROW_CONTINUATION_LINE_P (row),
 22542                MATRIX_ROW_DISPLAYS_TEXT_P (row),
 22543                row->ends_at_zv_p,
 22544                row->fill_line_p,
 22545                row->ends_in_middle_of_char_p,
 22546                row->starts_in_middle_of_char_p,
 22547                row->mouse_face_p,
 22548                row->x,
 22549                row->y,
 22550                row->pixel_width,
 22551                row->height,
 22552                row->visible_height,
 22553                row->ascent,
 22554                row->phys_ascent);
 22555       /* The next 3 lines should align to "Start" in the header.  */
 22556       fprintf (stderr, "    %9"pD"d %9"pD"d\t%5d\n", row->start.overlay_string_index,
 22557                row->end.overlay_string_index,
 22558                row->continuation_lines_width);
 22559       fprintf (stderr, "    %9"pD"d %9"pD"d\n",
 22560                CHARPOS (row->start.string_pos),
 22561                CHARPOS (row->end.string_pos));
 22562       fprintf (stderr, "    %9d %9d\n", row->start.dpvec_index,
 22563                row->end.dpvec_index);
 22564     }
 22565 
 22566   if (glyphs > 1)
 22567     {
 22568       int area;
 22569 
 22570       for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
 22571         {
 22572           struct glyph *glyph = row->glyphs[area];
 22573           struct glyph *glyph_end = glyph + row->used[area];
 22574 
 22575           /* Glyph for a line end in text.  */
 22576           if (area == TEXT_AREA && glyph == glyph_end && glyph->charpos > 0)
 22577             ++glyph_end;
 22578 
 22579           if (glyph < glyph_end)
 22580             fputs (" Glyph#  Type       Pos   O   W     Code      C Face LR\n",
 22581                    stderr);
 22582 
 22583           for (; glyph < glyph_end; ++glyph)
 22584             dump_glyph (row, glyph, area);
 22585         }
 22586     }
 22587   else if (glyphs == 1)
 22588     {
 22589       int area;
 22590       char s[SHRT_MAX + 4];
 22591 
 22592       for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
 22593         {
 22594           int i;
 22595 
 22596           for (i = 0; i < row->used[area]; ++i)
 22597             {
 22598               struct glyph *glyph = row->glyphs[area] + i;
 22599               if (i == row->used[area] - 1
 22600                   && area == TEXT_AREA
 22601                   && NILP (glyph->object)
 22602                   && glyph->type == CHAR_GLYPH
 22603                   && glyph->u.ch == ' ')
 22604                 {
 22605                   strcpy (&s[i], "[\\n]");
 22606                   i += 4;
 22607                 }
 22608               else if (glyph->type == CHAR_GLYPH
 22609                        && glyph->u.ch < 0x80
 22610                        && glyph->u.ch >= ' ')
 22611                 s[i] = glyph->u.ch;
 22612               else
 22613                 s[i] = '.';
 22614             }
 22615 
 22616           s[i] = '\0';
 22617           fprintf (stderr, "%3d: (%d) '%s'\n", vpos, row->enabled_p, s);
 22618         }
 22619     }
 22620 }
 22621 
 22622 
 22623 DEFUN ("dump-glyph-matrix", Fdump_glyph_matrix,
 22624        Sdump_glyph_matrix, 0, 1, "p",
 22625        doc: /* Dump the current matrix of the selected window to stderr.
 22626 Shows contents of glyph row structures.  With non-nil
 22627 parameter GLYPHS, dump glyphs as well.  If GLYPHS is 1 show
 22628 glyphs in short form, otherwise show glyphs in long form.
 22629 
 22630 Interactively, no argument means show glyphs in short form;
 22631 with numeric argument, its value is passed as the GLYPHS flag.  */)
 22632   (Lisp_Object glyphs)
 22633 {
 22634   struct window *w = XWINDOW (selected_window);
 22635   struct buffer *buffer = XBUFFER (w->contents);
 22636 
 22637   fprintf (stderr, "PT = %"pD"d, BEGV = %"pD"d. ZV = %"pD"d\n",
 22638            BUF_PT (buffer), BUF_BEGV (buffer), BUF_ZV (buffer));
 22639   fprintf (stderr, "Cursor x = %d, y = %d, hpos = %d, vpos = %d\n",
 22640            w->cursor.x, w->cursor.y, w->cursor.hpos, w->cursor.vpos);
 22641   fputs ("=============================================\n", stderr);
 22642   dump_glyph_matrix (w->current_matrix,
 22643                      TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 0);
 22644   return Qnil;
 22645 }
 22646 
 22647 
 22648 DEFUN ("dump-frame-glyph-matrix", Fdump_frame_glyph_matrix,
 22649        Sdump_frame_glyph_matrix, 0, 0, "", doc: /* Dump the current glyph matrix of the selected frame to stderr.
 22650 Only text-mode frames have frame glyph matrices.  */)
 22651   (void)
 22652 {
 22653   struct frame *f = XFRAME (selected_frame);
 22654 
 22655   if (f->current_matrix)
 22656     dump_glyph_matrix (f->current_matrix, 1);
 22657   else
 22658     fputs ("*** This frame doesn't have a frame glyph matrix ***\n", stderr);
 22659   return Qnil;
 22660 }
 22661 
 22662 
 22663 DEFUN ("dump-glyph-row", Fdump_glyph_row, Sdump_glyph_row, 1, 2, "P",
 22664        doc: /* Dump glyph row ROW to stderr.
 22665 Interactively, ROW is the prefix numeric argument and defaults to
 22666 the row which displays point.
 22667 Optional argument GLYPHS 0 means don't dump glyphs.
 22668 GLYPHS 1 means dump glyphs in short form.
 22669 GLYPHS > 1 or omitted means dump glyphs in long form.  */)
 22670   (Lisp_Object row, Lisp_Object glyphs)
 22671 {
 22672   struct glyph_matrix *matrix;
 22673   EMACS_INT vpos;
 22674 
 22675   if (NILP (row))
 22676     {
 22677       int d1, d2, d3, d4, d5, ypos;
 22678       bool visible_p = pos_visible_p (XWINDOW (selected_window), PT,
 22679                                       &d1, &d2, &d3, &d4, &d5, &ypos);
 22680       if (visible_p)
 22681         vpos = ypos;
 22682       else
 22683         vpos = 0;
 22684     }
 22685   else
 22686     {
 22687       CHECK_FIXNUM (row);
 22688       vpos = XFIXNUM (row);
 22689     }
 22690   matrix = XWINDOW (selected_window)->current_matrix;
 22691   if (vpos >= 0 && vpos < matrix->nrows)
 22692     dump_glyph_row (MATRIX_ROW (matrix, vpos),
 22693                     vpos,
 22694                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
 22695   return Qnil;
 22696 }
 22697 
 22698 
 22699 DEFUN ("dump-tab-bar-row", Fdump_tab_bar_row, Sdump_tab_bar_row, 1, 2, "P",
 22700        doc: /* Dump glyph row ROW of the tab-bar of the current frame to stderr.
 22701 Interactively, ROW is the prefix numeric argument and defaults to zero.
 22702 GLYPHS 0 means don't dump glyphs.
 22703 GLYPHS 1 means dump glyphs in short form.
 22704 GLYPHS > 1 or omitted means dump glyphs in long form.
 22705 
 22706 If there's no tab-bar, or if the tab-bar is not drawn by Emacs,
 22707 do nothing.  */)
 22708   (Lisp_Object row, Lisp_Object glyphs)
 22709 {
 22710 #if defined (HAVE_WINDOW_SYSTEM)
 22711   struct frame *sf = SELECTED_FRAME ();
 22712   struct glyph_matrix *m = WINDOWP (sf->tab_bar_window)
 22713     ? XWINDOW (sf->tab_bar_window)->current_matrix
 22714     : sf->current_matrix;
 22715   EMACS_INT vpos;
 22716 
 22717   if (NILP (row))
 22718     vpos = WINDOWP (sf->tab_bar_window) ? 0 :
 22719       FRAME_MENU_BAR_LINES (sf) > 0 ? 1 : 0;
 22720   else
 22721     {
 22722       CHECK_FIXNUM (row);
 22723       vpos = XFIXNUM (row);
 22724     }
 22725   if (vpos >= 0 && vpos < m->nrows)
 22726     dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
 22727                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
 22728 #endif
 22729   return Qnil;
 22730 }
 22731 
 22732 DEFUN ("dump-tool-bar-row", Fdump_tool_bar_row, Sdump_tool_bar_row, 1, 2, "P",
 22733        doc: /* Dump glyph row ROW of the tool-bar of the current frame to stderr.
 22734 Interactively, ROW is the prefix numeric argument and defaults to zero.
 22735 GLYPHS 0 means don't dump glyphs.
 22736 GLYPHS 1 means dump glyphs in short form.
 22737 GLYPHS > 1 or omitted means dump glyphs in long form.
 22738 
 22739 If there's no tool-bar, or if the tool-bar is not drawn by Emacs,
 22740 do nothing.  */)
 22741   (Lisp_Object row, Lisp_Object glyphs)
 22742 {
 22743 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (HAVE_EXT_TOOL_BAR)
 22744   struct frame *sf = SELECTED_FRAME ();
 22745   struct glyph_matrix *m = XWINDOW (sf->tool_bar_window)->current_matrix;
 22746   EMACS_INT vpos;
 22747 
 22748   if (NILP (row))
 22749     vpos = 0;
 22750   else
 22751     {
 22752       CHECK_FIXNUM (row);
 22753       vpos = XFIXNUM (row);
 22754     }
 22755   if (vpos >= 0 && vpos < m->nrows)
 22756     dump_glyph_row (MATRIX_ROW (m, vpos), vpos,
 22757                     TYPE_RANGED_FIXNUMP (int, glyphs) ? XFIXNUM (glyphs) : 2);
 22758 #endif
 22759   return Qnil;
 22760 }
 22761 
 22762 
 22763 DEFUN ("trace-redisplay", Ftrace_redisplay, Strace_redisplay, 0, 1, "P",
 22764        doc: /* Toggle tracing of redisplay.
 22765 With ARG, turn tracing on if and only if ARG is positive.  */)
 22766   (Lisp_Object arg)
 22767 {
 22768   if (NILP (arg))
 22769     trace_redisplay_p = !trace_redisplay_p;
 22770   else
 22771     {
 22772       arg = Fprefix_numeric_value (arg);
 22773       trace_redisplay_p = XFIXNUM (arg) > 0;
 22774     }
 22775 
 22776   return Qnil;
 22777 }
 22778 
 22779 
 22780 DEFUN ("trace-to-stderr", Ftrace_to_stderr, Strace_to_stderr, 1, MANY, "",
 22781        doc: /* Like `format', but print result to stderr.
 22782 usage: (trace-to-stderr STRING &rest OBJECTS)  */)
 22783   (ptrdiff_t nargs, Lisp_Object *args)
 22784 {
 22785   Lisp_Object s = Fformat (nargs, args);
 22786   fwrite (SDATA (s), 1, SBYTES (s), stderr);
 22787   return Qnil;
 22788 }
 22789 
 22790 #endif /* GLYPH_DEBUG */
 22791 
 22792 
 22793 
 22794 /***********************************************************************
 22795                      Building Desired Matrix Rows
 22796  ***********************************************************************/
 22797 
 22798 /* Return a temporary glyph row holding the glyphs of an overlay arrow.
 22799    Used for non-window-redisplay windows, and for windows without left
 22800    fringe.  */
 22801 
 22802 static struct glyph_row *
 22803 get_overlay_arrow_glyph_row (struct window *w, Lisp_Object overlay_arrow_string)
 22804 {
 22805   struct frame *f = XFRAME (WINDOW_FRAME (w));
 22806   struct buffer *buffer = XBUFFER (w->contents);
 22807   struct buffer *old = current_buffer;
 22808   const unsigned char *arrow_string = SDATA (overlay_arrow_string);
 22809   ptrdiff_t arrow_len = SBYTES (overlay_arrow_string), char_num = 0;
 22810   const unsigned char *arrow_end = arrow_string + arrow_len;
 22811   const unsigned char *p;
 22812   struct it it;
 22813   bool multibyte_p;
 22814   int n_glyphs_before;
 22815 
 22816   set_buffer_temp (buffer);
 22817   init_iterator (&it, w, -1, -1, &scratch_glyph_row, DEFAULT_FACE_ID);
 22818   scratch_glyph_row.reversed_p = false;
 22819   it.glyph_row->used[TEXT_AREA] = 0;
 22820   SET_TEXT_POS (it.position, 0, 0);
 22821 
 22822   multibyte_p = !NILP (BVAR (buffer, enable_multibyte_characters));
 22823   p = arrow_string;
 22824   while (p < arrow_end)
 22825     {
 22826       Lisp_Object face, ilisp;
 22827 
 22828       /* Get the next character.  */
 22829       if (multibyte_p)
 22830         it.c = it.char_to_display = check_char_and_length (p, &it.len);
 22831       else
 22832         {
 22833           it.c = it.char_to_display = *p, it.len = 1;
 22834           if (! ASCII_CHAR_P (it.c))
 22835             it.char_to_display = BYTE8_TO_CHAR (it.c);
 22836         }
 22837       p += it.len;
 22838 
 22839       /* Get its face.  */
 22840       ilisp = make_fixnum (char_num++);
 22841       face = Fget_text_property (ilisp, Qface, overlay_arrow_string);
 22842       it.face_id = compute_char_face (f, it.char_to_display, face);
 22843 
 22844       /* Compute its width, get its glyphs.  */
 22845       n_glyphs_before = it.glyph_row->used[TEXT_AREA];
 22846       SET_TEXT_POS (it.position, -1, -1);
 22847       PRODUCE_GLYPHS (&it);
 22848 
 22849       /* If this character doesn't fit any more in the line, we have
 22850          to remove some glyphs.  */
 22851       if (it.current_x > it.last_visible_x)
 22852         {
 22853           it.glyph_row->used[TEXT_AREA] = n_glyphs_before;
 22854           break;
 22855         }
 22856     }
 22857 
 22858   set_buffer_temp (old);
 22859   return it.glyph_row;
 22860 }
 22861 
 22862 
 22863 /* Insert truncation glyphs at the start of IT->glyph_row.  Which
 22864    glyphs to insert is determined by produce_special_glyphs.  */
 22865 
 22866 static void
 22867 insert_left_trunc_glyphs (struct it *it)
 22868 {
 22869   struct it truncate_it;
 22870   struct glyph *from, *end, *to, *toend;
 22871 
 22872   eassert (!FRAME_WINDOW_P (it->f)
 22873            || (!it->glyph_row->reversed_p
 22874                && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0)
 22875            || (it->glyph_row->reversed_p
 22876                && WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0));
 22877 
 22878   /* Get the truncation glyphs.  */
 22879   truncate_it = *it;
 22880   truncate_it.current_x = 0;
 22881   truncate_it.face_id = DEFAULT_FACE_ID;
 22882   truncate_it.glyph_row = &scratch_glyph_row;
 22883   truncate_it.area = TEXT_AREA;
 22884   truncate_it.glyph_row->used[TEXT_AREA] = 0;
 22885   CHARPOS (truncate_it.position) = BYTEPOS (truncate_it.position) = -1;
 22886   truncate_it.object = Qnil;
 22887   produce_special_glyphs (&truncate_it, IT_TRUNCATION);
 22888 
 22889   /* Overwrite glyphs from IT with truncation glyphs.  */
 22890   if (!it->glyph_row->reversed_p)
 22891     {
 22892       short tused = truncate_it.glyph_row->used[TEXT_AREA];
 22893 
 22894       from = truncate_it.glyph_row->glyphs[TEXT_AREA];
 22895       end = from + tused;
 22896       to = it->glyph_row->glyphs[TEXT_AREA];
 22897       toend = to + it->glyph_row->used[TEXT_AREA];
 22898       if (FRAME_WINDOW_P (it->f))
 22899         {
 22900           /* On GUI frames, when variable-size fonts are displayed,
 22901              the truncation glyphs may need more pixels than the row's
 22902              glyphs they overwrite.  We overwrite more glyphs to free
 22903              enough screen real estate, and enlarge the stretch glyph
 22904              on the right (see display_line), if there is one, to
 22905              preserve the screen position of the truncation glyphs on
 22906              the right.  */
 22907           int w = 0;
 22908           struct glyph *g = to;
 22909           short used;
 22910 
 22911           /* The first glyph could be partially visible, in which case
 22912              it->glyph_row->x will be negative.  But we want the left
 22913              truncation glyphs to be aligned at the left margin of the
 22914              window, so we override the x coordinate at which the row
 22915              will begin.  */
 22916           it->glyph_row->x = 0;
 22917           while (g < toend && w < it->truncation_pixel_width)
 22918             {
 22919               w += g->pixel_width;
 22920               ++g;
 22921             }
 22922           if (g - to - tused > 0)
 22923             {
 22924               memmove (to + tused, g, (toend - g) * sizeof(*g));
 22925               it->glyph_row->used[TEXT_AREA] -= g - to - tused;
 22926             }
 22927           used = it->glyph_row->used[TEXT_AREA];
 22928           if (it->glyph_row->truncated_on_right_p
 22929               && WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0
 22930               && it->glyph_row->glyphs[TEXT_AREA][used - 2].type
 22931               == STRETCH_GLYPH)
 22932             {
 22933               int extra = w - it->truncation_pixel_width;
 22934 
 22935               it->glyph_row->glyphs[TEXT_AREA][used - 2].pixel_width += extra;
 22936             }
 22937         }
 22938 
 22939       while (from < end)
 22940         *to++ = *from++;
 22941 
 22942       /* There may be padding glyphs left over.  Overwrite them too.  */
 22943       if (!FRAME_WINDOW_P (it->f))
 22944         {
 22945           while (to < toend && CHAR_GLYPH_PADDING_P (*to))
 22946             {
 22947               from = truncate_it.glyph_row->glyphs[TEXT_AREA];
 22948               while (from < end)
 22949                 *to++ = *from++;
 22950             }
 22951         }
 22952 
 22953       if (to > toend)
 22954         it->glyph_row->used[TEXT_AREA] = to - it->glyph_row->glyphs[TEXT_AREA];
 22955     }
 22956   else
 22957     {
 22958       short tused = truncate_it.glyph_row->used[TEXT_AREA];
 22959 
 22960       /* In R2L rows, overwrite the last (rightmost) glyphs, and do
 22961          that back to front.  */
 22962       end = truncate_it.glyph_row->glyphs[TEXT_AREA];
 22963       from = end + truncate_it.glyph_row->used[TEXT_AREA] - 1;
 22964       toend = it->glyph_row->glyphs[TEXT_AREA];
 22965       to = toend + it->glyph_row->used[TEXT_AREA] - 1;
 22966       if (FRAME_WINDOW_P (it->f))
 22967         {
 22968           int w = 0;
 22969           struct glyph *g = to;
 22970 
 22971           while (g >= toend && w < it->truncation_pixel_width)
 22972             {
 22973               w += g->pixel_width;
 22974               --g;
 22975             }
 22976           if (to - g - tused > 0)
 22977             to = g + tused;
 22978           if (it->glyph_row->truncated_on_right_p
 22979               && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0
 22980               && it->glyph_row->glyphs[TEXT_AREA][1].type == STRETCH_GLYPH)
 22981             {
 22982               int extra = w - it->truncation_pixel_width;
 22983 
 22984               it->glyph_row->glyphs[TEXT_AREA][1].pixel_width += extra;
 22985             }
 22986         }
 22987 
 22988       while (from >= end && to >= toend)
 22989         *to-- = *from--;
 22990       if (!FRAME_WINDOW_P (it->f))
 22991         {
 22992           while (to >= toend && CHAR_GLYPH_PADDING_P (*to))
 22993             {
 22994               from =
 22995                 truncate_it.glyph_row->glyphs[TEXT_AREA]
 22996                 + truncate_it.glyph_row->used[TEXT_AREA] - 1;
 22997               while (from >= end && to >= toend)
 22998                 *to-- = *from--;
 22999             }
 23000         }
 23001       if (from >= end)
 23002         {
 23003           /* Need to free some room before prepending additional
 23004              glyphs.  */
 23005           int move_by = from - end + 1;
 23006           struct glyph *g0 = it->glyph_row->glyphs[TEXT_AREA];
 23007           struct glyph *g = g0 + it->glyph_row->used[TEXT_AREA] - 1;
 23008 
 23009           for ( ; g >= g0; g--)
 23010             g[move_by] = *g;
 23011           while (from >= end)
 23012             *to-- = *from--;
 23013           it->glyph_row->used[TEXT_AREA] += move_by;
 23014         }
 23015     }
 23016 }
 23017 
 23018 /* Compute the hash code for ROW.  */
 23019 unsigned
 23020 row_hash (struct glyph_row *row)
 23021 {
 23022   int area, k;
 23023   unsigned hashval = 0;
 23024 
 23025   for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
 23026     for (k = 0; k < row->used[area]; ++k)
 23027       hashval = ((((hashval << 4) + (hashval >> 24)) & 0x0fffffff)
 23028                   + row->glyphs[area][k].u.val
 23029                   + row->glyphs[area][k].face_id
 23030                   + row->glyphs[area][k].padding_p
 23031                   + (row->glyphs[area][k].type << 2));
 23032 
 23033   return hashval;
 23034 }
 23035 
 23036 /* Compute the pixel height and width of IT->glyph_row.
 23037 
 23038    Most of the time, ascent and height of a display line will be equal
 23039    to the max_ascent and max_height values of the display iterator
 23040    structure.  This is not the case if
 23041 
 23042    1. We hit ZV without displaying anything.  In this case, max_ascent
 23043    and max_height will be zero.
 23044 
 23045    2. We have some glyphs that don't contribute to the line height.
 23046    (The glyph row flag contributes_to_line_height_p is for future
 23047    pixmap extensions).
 23048 
 23049    The first case is easily covered by using default values because in
 23050    these cases, the line height does not really matter, except that it
 23051    must not be zero.  */
 23052 
 23053 static void
 23054 compute_line_metrics (struct it *it)
 23055 {
 23056   struct glyph_row *row = it->glyph_row;
 23057 
 23058   if (FRAME_WINDOW_P (it->f))
 23059     {
 23060       int i, min_y, max_y;
 23061 
 23062       /* The line may consist of one space only, that was added to
 23063          place the cursor on it.  If so, the row's height hasn't been
 23064          computed yet.  */
 23065       if (row->height == 0)
 23066         {
 23067           if (it->max_ascent + it->max_descent == 0)
 23068             it->max_descent = it->max_phys_descent = FRAME_LINE_HEIGHT (it->f);
 23069           row->ascent = it->max_ascent;
 23070           row->height = it->max_ascent + it->max_descent;
 23071           row->phys_ascent = it->max_phys_ascent;
 23072           row->phys_height = it->max_phys_ascent + it->max_phys_descent;
 23073           row->extra_line_spacing = it->max_extra_line_spacing;
 23074         }
 23075 
 23076       /* Compute the width of this line.  */
 23077       row->pixel_width = row->x;
 23078       for (i = 0; i < row->used[TEXT_AREA]; ++i)
 23079         row->pixel_width += row->glyphs[TEXT_AREA][i].pixel_width;
 23080 
 23081       eassert (row->pixel_width >= 0);
 23082       eassert (row->ascent >= 0 && row->height > 0);
 23083 
 23084       row->overlapping_p = (MATRIX_ROW_OVERLAPS_SUCC_P (row)
 23085                             || MATRIX_ROW_OVERLAPS_PRED_P (row));
 23086 
 23087       /* If first line's physical ascent is larger than its logical
 23088          ascent, use the physical ascent, and make the row taller.
 23089          This makes accented characters fully visible.  */
 23090       if (row == MATRIX_FIRST_TEXT_ROW (it->w->desired_matrix)
 23091           && row->phys_ascent > row->ascent)
 23092         {
 23093           row->height += row->phys_ascent - row->ascent;
 23094           row->ascent = row->phys_ascent;
 23095         }
 23096 
 23097       /* Compute how much of the line is visible.  */
 23098       row->visible_height = row->height;
 23099 
 23100       min_y = WINDOW_TAB_LINE_HEIGHT (it->w) + WINDOW_HEADER_LINE_HEIGHT (it->w);
 23101       max_y = WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w);
 23102 
 23103       if (row->y < min_y)
 23104         row->visible_height -= min_y - row->y;
 23105       if (row->y + row->height > max_y)
 23106         row->visible_height -= row->y + row->height - max_y;
 23107     }
 23108   else
 23109     {
 23110       row->pixel_width = row->used[TEXT_AREA];
 23111       if (row->continued_p)
 23112         row->pixel_width -= it->continuation_pixel_width;
 23113       else if (row->truncated_on_right_p)
 23114         row->pixel_width -= it->truncation_pixel_width;
 23115       row->ascent = row->phys_ascent = 0;
 23116       row->height = row->phys_height = row->visible_height = 1;
 23117       row->extra_line_spacing = 0;
 23118     }
 23119 
 23120   /* Compute a hash code for this row.  */
 23121   row->hash = row_hash (row);
 23122 
 23123   it->max_ascent = it->max_descent = 0;
 23124   it->max_phys_ascent = it->max_phys_descent = 0;
 23125 }
 23126 
 23127 
 23128 static void
 23129 clear_position (struct it *it)
 23130 {
 23131   it->position.charpos = 0;
 23132   it->position.bytepos = 0;
 23133 }
 23134 
 23135 /* Append one space to the glyph row of iterator IT if doing a
 23136    window-based redisplay.  The space has the same face as
 23137    IT->face_id.  Value is true if a space was added.
 23138 
 23139    This function is called to make sure that there is always one glyph
 23140    at the end of a glyph row that the cursor can be set on under
 23141    window-systems.  (If there weren't such a glyph we would not know
 23142    how wide and tall a box cursor should be displayed).
 23143 
 23144    At the same time this space let's a nicely handle clearing to the
 23145    end of the line if the row ends in italic text.  */
 23146 
 23147 static bool
 23148 append_space_for_newline (struct it *it, bool default_face_p)
 23149 {
 23150   int n = it->glyph_row->used[TEXT_AREA];
 23151 
 23152   if (it->glyph_row->glyphs[TEXT_AREA] + n
 23153       < it->glyph_row->glyphs[1 + TEXT_AREA])
 23154     {
 23155       /* Save some values that must not be changed.
 23156          Must save IT->c and IT->len because otherwise
 23157          ITERATOR_AT_END_P wouldn't work anymore after
 23158          append_space_for_newline has been called.  */
 23159       enum display_element_type saved_what = it->what;
 23160       int saved_c = it->c, saved_len = it->len;
 23161       int saved_char_to_display = it->char_to_display;
 23162       int saved_x = it->current_x;
 23163       const int saved_face_id = it->face_id;
 23164       bool saved_box_end = it->end_of_box_run_p;
 23165       struct text_pos saved_pos = it->position;
 23166       Lisp_Object saved_object = it->object;
 23167       struct face *face;
 23168 
 23169       it->what = IT_CHARACTER;
 23170       clear_position (it);
 23171       it->object = Qnil;
 23172       it->len = 1;
 23173 
 23174       int char_width = 1;
 23175 
 23176       if (default_face_p
 23177 #ifdef HAVE_WINDOW_SYSTEM
 23178           || FRAME_WINDOW_P (it->f)
 23179 #endif
 23180           )
 23181         {
 23182           const int local_default_face_id =
 23183             lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID);
 23184 
 23185 #ifdef HAVE_WINDOW_SYSTEM
 23186           if (FRAME_WINDOW_P (it->f))
 23187             {
 23188               struct face *default_face
 23189                 = FACE_FROM_ID (it->f, local_default_face_id);
 23190               struct font *font = (default_face->font
 23191                                    ? default_face->font
 23192                                    : FRAME_FONT (it->f));
 23193               char_width = (font->average_width
 23194                             ? font->average_width
 23195                             : font->space_width);
 23196             }
 23197 #endif
 23198           if (default_face_p)
 23199             it->face_id = local_default_face_id;
 23200         }
 23201       /* Corner case for when display-fill-column-indicator-mode
 23202          is active and the extra character should be added in the
 23203          same place than the line.  */
 23204 
 23205       const int indicator_column =
 23206         fill_column_indicator_column (it, char_width);
 23207       int saved_end_of_box_run = it->end_of_box_run_p;
 23208       bool should_keep_end_of_box_run = false;
 23209 
 23210       if (it->current_x == indicator_column)
 23211         {
 23212           it->c = it->char_to_display
 23213             = XFIXNAT (Vdisplay_fill_column_indicator_character);
 23214           it->face_id
 23215             = merge_faces (it->w, Qfill_column_indicator,
 23216                            0, saved_face_id);
 23217           face = FACE_FROM_ID (it->f, it->face_id);
 23218         }
 23219       else
 23220         {
 23221           it->c = it->char_to_display = ' ';
 23222           /* If the default face was remapped, be sure to use the
 23223              remapped face for the appended newline.  */
 23224 
 23225           face = FACE_FROM_ID (it->f, it->face_id);
 23226           it->face_id = FACE_FOR_CHAR (it->f, face, 0, -1, Qnil);
 23227           /* In R2L rows, we will prepend a stretch glyph that will
 23228              have the end_of_box_run_p flag set for it, so there's no
 23229              need for the appended newline glyph to have that flag
 23230              set.  */
 23231           if (!(it->glyph_row->reversed_p
 23232                 /* But if the appended newline glyph goes all the way to
 23233                    the end of the row, there will be no stretch glyph,
 23234                    so leave the box flag set.  */
 23235                 && saved_x + FRAME_COLUMN_WIDTH (it->f) < it->last_visible_x))
 23236             should_keep_end_of_box_run = true;
 23237         }
 23238       PRODUCE_GLYPHS (it);
 23239       /* Restore the end_of_box_run_p flag which was reset by
 23240          PRODUCE_GLYPHS.  */
 23241       if (should_keep_end_of_box_run)
 23242         it->end_of_box_run_p = saved_end_of_box_run;
 23243 #ifdef HAVE_WINDOW_SYSTEM
 23244       if (FRAME_WINDOW_P (it->f))
 23245         {
 23246           /* Make sure this space glyph has the right ascent and
 23247              descent values, or else cursor at end of line will look
 23248              funny, and height of empty lines will be incorrect.  */
 23249           struct glyph *g = it->glyph_row->glyphs[TEXT_AREA] + n;
 23250           struct font *font = face->font ? face->font : FRAME_FONT (it->f);
 23251           if (n == 0)
 23252             {
 23253               Lisp_Object height, total_height;
 23254               int extra_line_spacing = it->extra_line_spacing;
 23255               int boff = font->baseline_offset;
 23256 
 23257               if (font->vertical_centering)
 23258                 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 23259 
 23260               it->object = saved_object; /* get_it_property needs this */
 23261               normal_char_ascent_descent (font, -1, &it->ascent, &it->descent);
 23262               /* Must do a subset of line height processing from
 23263                  gui_produce_glyph for newline characters.  */
 23264               height = get_it_property (it, Qline_height);
 23265               if (CONSP (height)
 23266                   && CONSP (XCDR (height))
 23267                   && NILP (XCDR (XCDR (height))))
 23268                 {
 23269                   total_height = XCAR (XCDR (height));
 23270                   height = XCAR (height);
 23271                 }
 23272               else
 23273                 total_height = Qnil;
 23274               height = calc_line_height_property (it, height, font, boff, true);
 23275 
 23276               if (it->override_ascent >= 0)
 23277                 {
 23278                   it->ascent = it->override_ascent;
 23279                   it->descent = it->override_descent;
 23280                   boff = it->override_boff;
 23281                 }
 23282               if (EQ (height, Qt))
 23283                 extra_line_spacing = 0;
 23284               else
 23285                 {
 23286                   Lisp_Object spacing;
 23287 
 23288                   it->phys_ascent = it->ascent;
 23289                   it->phys_descent = it->descent;
 23290                   if (!NILP (height)
 23291                       && XFIXNUM (height) > it->ascent + it->descent)
 23292                     it->ascent = XFIXNUM (height) - it->descent;
 23293 
 23294                   if (!NILP (total_height))
 23295                     spacing = calc_line_height_property (it, total_height, font,
 23296                                                          boff, false);
 23297                   else
 23298                     {
 23299                       spacing = get_it_property (it, Qline_spacing);
 23300                       spacing = calc_line_height_property (it, spacing, font,
 23301                                                            boff, false);
 23302                     }
 23303                   if (FIXNUMP (spacing))
 23304                     {
 23305                       extra_line_spacing = XFIXNUM (spacing);
 23306                       if (!NILP (total_height))
 23307                         extra_line_spacing -= (it->phys_ascent + it->phys_descent);
 23308                     }
 23309                 }
 23310               if (extra_line_spacing > 0)
 23311                 {
 23312                   it->descent += extra_line_spacing;
 23313                   if (extra_line_spacing > it->max_extra_line_spacing)
 23314                     it->max_extra_line_spacing = extra_line_spacing;
 23315                 }
 23316               it->max_ascent = it->ascent;
 23317               it->max_descent = it->descent;
 23318               /* Make sure compute_line_metrics recomputes the row height.  */
 23319               it->glyph_row->height = 0;
 23320             }
 23321 
 23322           g->ascent = it->max_ascent;
 23323           g->descent = it->max_descent;
 23324         }
 23325 #endif /* HAVE_WINDOW_SYSTEM  */
 23326       it->override_ascent = -1;
 23327       it->constrain_row_ascent_descent_p = false;
 23328       it->current_x = saved_x;
 23329       it->object = saved_object;
 23330       it->position = saved_pos;
 23331       it->what = saved_what;
 23332       it->face_id = saved_face_id;
 23333       it->len = saved_len;
 23334       it->c = saved_c;
 23335       it->char_to_display = saved_char_to_display;
 23336       it->end_of_box_run_p = saved_box_end;
 23337       return true;
 23338     }
 23339 
 23340   return false;
 23341 }
 23342 
 23343 
 23344 /* Extend the face of the last glyph in the text area of IT->glyph_row
 23345    to the end of the display line.  Called from display_line.  If the
 23346    glyph row is empty, add a space glyph to it so that we know the
 23347    face to draw.  Set the glyph row flag fill_line_p.  If the glyph
 23348    row is R2L, prepend a stretch glyph to cover the empty space to the
 23349    left of the leftmost glyph.  */
 23350 
 23351 static void
 23352 extend_face_to_end_of_line (struct it *it)
 23353 {
 23354   struct frame *f = it->f;
 23355 
 23356   /* If line is already filled, do nothing.  Non window-system frames
 23357      get a grace of one more ``pixel'' because their characters are
 23358      1-``pixel'' wide, so they hit the equality too early.  This grace
 23359      is needed only for R2L rows that are not continued, to produce
 23360      one extra blank where we could display the cursor.  */
 23361   if ((it->current_x >= it->last_visible_x
 23362        + (!FRAME_WINDOW_P (f)
 23363           && it->glyph_row->reversed_p
 23364           && !it->glyph_row->continued_p))
 23365       /* If the window has display margins, we will need to extend
 23366          their face even if the text area is filled.  */
 23367       && !(WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 23368            || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0))
 23369     return;
 23370 
 23371   specpdl_ref count = SPECPDL_INDEX ();
 23372 
 23373   /* Don't allow the user to quit out of face-merging code, in case
 23374      this is called when redisplaying a non-selected window, with
 23375      point temporarily moved to window-point.  */
 23376   specbind (Qinhibit_quit, Qt);
 23377   /* The default face, possibly remapped. */
 23378   struct face *default_face =
 23379     FACE_FROM_ID_OR_NULL (f, lookup_basic_face (it->w, f, DEFAULT_FACE_ID));
 23380   if (!default_face)
 23381     return;
 23382 
 23383   const int extend_face_id =
 23384     (it->face_id == default_face->id || it->s != NULL)
 23385     ? it->face_id
 23386     : (it->glyph_row->ends_at_zv_p
 23387        ? default_face->id
 23388        : face_at_pos (it, LFACE_EXTEND_INDEX));
 23389   unbind_to (count, Qnil);
 23390 
 23391   /* Face extension extends the background and box of IT->extend_face_id
 23392      to the end of the line.  If the background equals the background
 23393      of the frame, we don't have to do anything.  */
 23394   struct face *face = FACE_FROM_ID (f, (it->face_before_selective_p
 23395                                         ? it->saved_face_id
 23396                                         : extend_face_id));
 23397 
 23398   if (FRAME_WINDOW_P (f)
 23399       && MATRIX_ROW_DISPLAYS_TEXT_P (it->glyph_row)
 23400       && face->box == FACE_NO_BOX
 23401       && face->underline == FACE_NO_UNDERLINE
 23402       && !face->overline_p
 23403       && !face->strike_through_p
 23404       && face->background == FRAME_BACKGROUND_PIXEL (f)
 23405 #ifdef HAVE_WINDOW_SYSTEM
 23406       && !face->stipple
 23407 #endif
 23408       && !it->glyph_row->reversed_p
 23409       && !display_fill_column_indicator)
 23410     return;
 23411 
 23412   /* Set the glyph row flag indicating that the face of the last glyph
 23413      in the text area has to be drawn to the end of the text area.  */
 23414   it->glyph_row->fill_line_p = true;
 23415 
 23416   const int orig_face_id = it->face_id;
 23417   /* If current character of IT is not ASCII, make sure we have the
 23418      ASCII face.  This will be automatically undone the next time
 23419      get_next_display_element returns a multibyte character.  Note
 23420      that the character will always be single byte in unibyte
 23421      text.  */
 23422   if (!ASCII_CHAR_P (it->c))
 23423     it->face_id = FACE_FOR_CHAR (f, face, 0, -1, Qnil);
 23424 
 23425 
 23426 #ifdef HAVE_WINDOW_SYSTEM
 23427   if (FRAME_WINDOW_P (f))
 23428     {
 23429       /* If the row is empty, add a space with the current face of IT,
 23430          so that we know which face to draw.  */
 23431       if (it->glyph_row->used[TEXT_AREA] == 0)
 23432         {
 23433           it->glyph_row->glyphs[TEXT_AREA][0] = space_glyph;
 23434           it->glyph_row->glyphs[TEXT_AREA][0].face_id = face->id;
 23435           it->glyph_row->used[TEXT_AREA] = 1;
 23436         }
 23437       /* Mode line and the header line don't have margins, and
 23438          likewise the frame's tool-bar window, if there is any.  */
 23439       if (!(it->glyph_row->mode_line_p
 23440             || (WINDOWP (f->tab_bar_window)
 23441                 && it->w == XWINDOW (f->tab_bar_window))
 23442 #ifndef HAVE_EXT_TOOL_BAR
 23443             || (WINDOWP (f->tool_bar_window)
 23444                 && it->w == XWINDOW (f->tool_bar_window))
 23445 #endif
 23446             ))
 23447         {
 23448           if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 23449               && it->glyph_row->used[LEFT_MARGIN_AREA] == 0)
 23450             {
 23451               it->glyph_row->glyphs[LEFT_MARGIN_AREA][0] = space_glyph;
 23452               it->glyph_row->glyphs[LEFT_MARGIN_AREA][0].face_id =
 23453                 default_face->id;
 23454               it->glyph_row->used[LEFT_MARGIN_AREA] = 1;
 23455             }
 23456           if (WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0
 23457               && it->glyph_row->used[RIGHT_MARGIN_AREA] == 0)
 23458             {
 23459               it->glyph_row->glyphs[RIGHT_MARGIN_AREA][0] = space_glyph;
 23460               it->glyph_row->glyphs[RIGHT_MARGIN_AREA][0].face_id =
 23461                 default_face->id;
 23462               it->glyph_row->used[RIGHT_MARGIN_AREA] = 1;
 23463             }
 23464 
 23465           struct font *font = (default_face->font
 23466                                ? default_face->font
 23467                                : FRAME_FONT (f));
 23468 
 23469           const int char_width = (font->average_width
 23470                                   ? font->average_width
 23471                                   : font->space_width);
 23472 
 23473           const int indicator_column =
 23474             fill_column_indicator_column (it, char_width);
 23475 
 23476           const char saved_char = it->char_to_display;
 23477           const struct text_pos saved_pos = it->position;
 23478           const bool saved_avoid_cursor = it->avoid_cursor_p;
 23479           const bool saved_box_start = it->start_of_box_run_p;
 23480           Lisp_Object save_object = it->object;
 23481           const int saved_face_id = it->face_id;
 23482 
 23483           it->face_id = extend_face_id;
 23484           it->avoid_cursor_p = true;
 23485           it->object = Qnil;
 23486 
 23487           const int stretch_height = it->ascent + it->descent;
 23488           const int stretch_ascent =
 23489             (stretch_height * FONT_BASE (font)) / FONT_HEIGHT (font);
 23490 
 23491           if (indicator_column >= 0
 23492               && indicator_column > it->current_x
 23493               && indicator_column < it->last_visible_x)
 23494             {
 23495 
 23496               /* Here we subtract char_width because we want the
 23497                  column indicator in the column INDICATOR_COLUMN,
 23498                  not after it.  */
 23499               const int stretch_width =
 23500                 indicator_column - it->current_x - char_width;
 23501 
 23502               clear_position (it);
 23503 
 23504               /* Only generate a stretch glyph if there is distance
 23505                  between current_x and the indicator position.  */
 23506               if (stretch_width > 0)
 23507                 {
 23508                   append_stretch_glyph (it, Qnil, stretch_width,
 23509                                         stretch_height, stretch_ascent);
 23510                 }
 23511 
 23512               /* Generate the glyph indicator only if
 23513                  append_space_for_newline didn't already.  */
 23514               if (it->current_x < indicator_column)
 23515                 {
 23516                   const int save_face_id = it->face_id;
 23517                   const int save_ascent = it->ascent;
 23518                   const int save_descent = it->descent;
 23519                   it->char_to_display
 23520                     = XFIXNAT (Vdisplay_fill_column_indicator_character);
 23521                   it->face_id
 23522                     = merge_faces (it->w, Qfill_column_indicator,
 23523                                    0, extend_face_id);
 23524                   PRODUCE_GLYPHS (it);
 23525                   it->face_id = save_face_id;
 23526                   it->ascent = save_ascent;
 23527                   it->descent = save_descent;
 23528                 }
 23529             }
 23530 
 23531           /* Fill space until window edge with the merged face.  Do that
 23532              only for L2R rows, as R2L rows are handled specially below.  */
 23533           if (!it->glyph_row->reversed_p)
 23534             {
 23535               const int stretch_width = it->last_visible_x - it->current_x;
 23536 
 23537               if (stretch_width > 0)
 23538                 {
 23539                   clear_position (it);
 23540                   append_stretch_glyph (it, Qnil, stretch_width,
 23541                                         stretch_height, stretch_ascent);
 23542                 }
 23543             }
 23544 
 23545           it->char_to_display = saved_char;
 23546           it->position = saved_pos;
 23547           it->avoid_cursor_p = saved_avoid_cursor;
 23548           it->start_of_box_run_p = saved_box_start;
 23549           it->object = save_object;
 23550           it->face_id = saved_face_id;
 23551         }
 23552       if (it->glyph_row->reversed_p)
 23553         {
 23554           /* Prepend a stretch glyph to the row, such that the
 23555              rightmost glyph will be drawn flushed all the way to the
 23556              right margin of the window.  The stretch glyph that will
 23557              occupy the empty space, if any, to the left of the
 23558              glyph.  */
 23559           struct font *font = face->font ? face->font : FRAME_FONT (f);
 23560           struct glyph *row_start = it->glyph_row->glyphs[TEXT_AREA];
 23561           struct glyph *row_end = row_start + it->glyph_row->used[TEXT_AREA];
 23562           struct glyph *g;
 23563           int row_width, stretch_ascent, stretch_width;
 23564           struct text_pos saved_pos;
 23565           int saved_face_id;
 23566           bool saved_avoid_cursor, saved_box_start;
 23567 
 23568           for (row_width = 0, g = row_start; g < row_end; g++)
 23569             row_width += g->pixel_width;
 23570 
 23571           /* FIXME: There are various minor display glitches in R2L
 23572              rows when only one of the fringes is missing.  The
 23573              strange condition below produces the least bad effect.  */
 23574           if ((WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0)
 23575               == (WINDOW_RIGHT_FRINGE_WIDTH (it->w) == 0)
 23576               || WINDOW_RIGHT_FRINGE_WIDTH (it->w) != 0)
 23577             stretch_width = window_box_width (it->w, TEXT_AREA);
 23578           else
 23579             stretch_width = it->last_visible_x - it->first_visible_x;
 23580           stretch_width -= row_width;
 23581 
 23582           if (stretch_width > 0)
 23583             {
 23584               stretch_ascent =
 23585                 (((it->ascent + it->descent)
 23586                   * FONT_BASE (font)) / FONT_HEIGHT (font));
 23587               saved_pos = it->position;
 23588               clear_position (it);
 23589               saved_avoid_cursor = it->avoid_cursor_p;
 23590               it->avoid_cursor_p = true;
 23591               saved_face_id = it->face_id;
 23592               saved_box_start = it->start_of_box_run_p;
 23593               /* The last row's stretch glyph should get the default
 23594                  face, to avoid painting the rest of the window with
 23595                  the region face, if the region ends at ZV.  */
 23596               it->face_id = (it->glyph_row->ends_at_zv_p ?
 23597                              default_face->id : face->id);
 23598 
 23599               it->start_of_box_run_p = false;
 23600               append_stretch_glyph (it, Qnil, stretch_width,
 23601                                     it->ascent + it->descent, stretch_ascent);
 23602               it->position = saved_pos;
 23603               it->avoid_cursor_p = saved_avoid_cursor;
 23604               it->face_id = saved_face_id;
 23605               it->start_of_box_run_p = saved_box_start;
 23606             }
 23607           /* If stretch_width comes out negative, it means that the
 23608              last glyph is only partially visible.  In R2L rows, we
 23609              want the leftmost glyph to be partially visible, so we
 23610              need to give the row the corresponding left offset.  */
 23611           if (stretch_width < 0)
 23612             it->glyph_row->x = stretch_width;
 23613         }
 23614       it->face_id = orig_face_id;
 23615     }
 23616   else
 23617 #endif  /* HAVE_WINDOW_SYSTEM */
 23618     {
 23619       /* Save some values that must not be changed.  */
 23620       int saved_x = it->current_x;
 23621       struct text_pos saved_pos = it->position;
 23622       Lisp_Object saved_object = it->object;;
 23623       enum display_element_type saved_what = it->what;
 23624 
 23625       it->what = IT_CHARACTER;
 23626       clear_position (it);
 23627       it->object = Qnil;
 23628       it->c = it->char_to_display = ' ';
 23629       it->len = 1;
 23630 
 23631       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 23632           && (it->glyph_row->used[LEFT_MARGIN_AREA]
 23633               < WINDOW_LEFT_MARGIN_WIDTH (it->w))
 23634           && !it->glyph_row->mode_line_p
 23635           && face->background != FRAME_BACKGROUND_PIXEL (f))
 23636         {
 23637           struct glyph *g = it->glyph_row->glyphs[LEFT_MARGIN_AREA];
 23638           struct glyph *e = g + it->glyph_row->used[LEFT_MARGIN_AREA];
 23639 
 23640           for (it->current_x = 0; g < e; g++)
 23641             it->current_x += g->pixel_width;
 23642 
 23643           it->area = LEFT_MARGIN_AREA;
 23644           it->face_id = default_face->id;
 23645           while (it->glyph_row->used[LEFT_MARGIN_AREA]
 23646                  < WINDOW_LEFT_MARGIN_WIDTH (it->w)
 23647                  && g < it->glyph_row->glyphs[TEXT_AREA])
 23648             {
 23649               PRODUCE_GLYPHS (it);
 23650               /* term.c:produce_glyphs advances it->current_x only for
 23651                  TEXT_AREA.  */
 23652               it->current_x += it->pixel_width;
 23653               g++;
 23654             }
 23655 
 23656           it->current_x = saved_x;
 23657           it->area = TEXT_AREA;
 23658         }
 23659 
 23660       /* The last row's blank glyphs should get the default face, to
 23661          avoid painting the rest of the window with the region face,
 23662          if the region ends at ZV.  */
 23663       it->face_id = (it->glyph_row->ends_at_zv_p ?
 23664                      default_face->id : face->id);
 23665 
 23666       /* Make sure our idea of current_x is in sync with the glyphs
 23667          actually in the glyph row.  They might differ because
 23668          append_space_for_newline can insert one glyph without
 23669          updating current_x.  */
 23670       it->current_x = it->glyph_row->used[TEXT_AREA];
 23671 
 23672       /* The above assignment causes the code below to use a
 23673          non-standard semantics of it->current_x: it is measured
 23674          relative to the beginning of the text-area, thus disregarding
 23675          the window's hscroll.  That is why we need to correct the
 23676          indicator column for the hscroll, otherwise the indicator
 23677          will not move together with the text as result of horizontal
 23678          scrolling.  */
 23679       const int indicator_column =
 23680         fill_column_indicator_column (it, 1) - it->first_visible_x;
 23681 
 23682       /* Display fill-column indicator if needed.  */
 23683       while (it->current_x <= it->last_visible_x)
 23684         {
 23685           if (it->current_x != indicator_column)
 23686             PRODUCE_GLYPHS (it);
 23687           else
 23688             {
 23689               int saved_face_id = it->face_id;
 23690               it->face_id
 23691                 = merge_faces (it->w, Qfill_column_indicator, 0, extend_face_id);
 23692               it->c = it->char_to_display
 23693                 = XFIXNAT (Vdisplay_fill_column_indicator_character);
 23694 
 23695               PRODUCE_GLYPHS (it);
 23696 
 23697               it->face_id = saved_face_id;
 23698               it->c = it->char_to_display = ' ';
 23699             }
 23700         }
 23701 
 23702       if (WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0
 23703           && (it->glyph_row->used[RIGHT_MARGIN_AREA]
 23704               < WINDOW_RIGHT_MARGIN_WIDTH (it->w))
 23705           && !it->glyph_row->mode_line_p
 23706           && face->background != FRAME_BACKGROUND_PIXEL (f))
 23707         {
 23708           struct glyph *g = it->glyph_row->glyphs[RIGHT_MARGIN_AREA];
 23709           struct glyph *e = g + it->glyph_row->used[RIGHT_MARGIN_AREA];
 23710 
 23711           for ( ; g < e; g++)
 23712             it->current_x += g->pixel_width;
 23713 
 23714           it->area = RIGHT_MARGIN_AREA;
 23715           it->face_id = default_face->id;
 23716           while (it->glyph_row->used[RIGHT_MARGIN_AREA]
 23717                  < WINDOW_RIGHT_MARGIN_WIDTH (it->w)
 23718                  && g < it->glyph_row->glyphs[LAST_AREA])
 23719             {
 23720               PRODUCE_GLYPHS (it);
 23721               it->current_x += it->pixel_width;
 23722               g++;
 23723             }
 23724 
 23725           it->area = TEXT_AREA;
 23726         }
 23727 
 23728       /* Don't count these blanks really.  It would let us insert a left
 23729          truncation glyph below and make us set the cursor on them, maybe.  */
 23730       it->current_x = saved_x;
 23731       it->object = saved_object;
 23732       it->position = saved_pos;
 23733       it->what = saved_what;
 23734       it->face_id = orig_face_id;
 23735     }
 23736 }
 23737 
 23738 
 23739 /* Value is true if text starting at CHARPOS in current_buffer is
 23740    trailing whitespace.  */
 23741 
 23742 static bool
 23743 trailing_whitespace_p (ptrdiff_t charpos)
 23744 {
 23745   ptrdiff_t bytepos = CHAR_TO_BYTE (charpos);
 23746   int c = 0;
 23747 
 23748   while (bytepos < ZV_BYTE
 23749          && (c = FETCH_BYTE (bytepos),
 23750              c == ' ' || c == '\t'))
 23751     ++bytepos;
 23752 
 23753   if (bytepos >= ZV_BYTE || c == '\n' || c == '\r')
 23754     {
 23755       if (bytepos != PT_BYTE)
 23756         return true;
 23757     }
 23758   return false;
 23759 }
 23760 
 23761 
 23762 /* Highlight trailing whitespace, if any, in row at IT.  */
 23763 
 23764 static void
 23765 highlight_trailing_whitespace (struct it *it)
 23766 {
 23767   struct glyph_row *row = it->glyph_row;
 23768   int used = row->used[TEXT_AREA];
 23769 
 23770   if (used)
 23771     {
 23772       struct glyph *start = row->glyphs[TEXT_AREA];
 23773       struct glyph *glyph = start + used - 1;
 23774 
 23775       if (row->reversed_p)
 23776         {
 23777           /* Right-to-left rows need to be processed in the opposite
 23778              direction, so swap the edge pointers. */
 23779           glyph = start;
 23780           start = row->glyphs[TEXT_AREA] + used - 1;
 23781         }
 23782 
 23783       /* Skip over glyphs inserted to display the cursor at the
 23784          end of a line, for extending the face of the last glyph
 23785          to the end of the line on terminals, and for truncation
 23786          and continuation glyphs.  */
 23787       if (!row->reversed_p)
 23788         {
 23789           while (glyph >= start
 23790                  && (glyph->type == CHAR_GLYPH
 23791                      || glyph->type == STRETCH_GLYPH)
 23792                  && NILP (glyph->object))
 23793             --glyph;
 23794         }
 23795       else
 23796         {
 23797           while (glyph <= start
 23798                  && (glyph->type == CHAR_GLYPH || glyph->type == STRETCH_GLYPH)
 23799                  && NILP (glyph->object))
 23800             ++glyph;
 23801         }
 23802 
 23803       /* If last glyph is a space or stretch, and it's trailing
 23804          whitespace, set the face of all trailing whitespace glyphs in
 23805          IT->glyph_row to `trailing-whitespace'.  */
 23806       if ((row->reversed_p ? glyph <= start : glyph >= start)
 23807           && BUFFERP (glyph->object)
 23808           && (glyph->type == STRETCH_GLYPH
 23809               || (glyph->type == CHAR_GLYPH
 23810                   && glyph->u.ch == ' '))
 23811           && trailing_whitespace_p (glyph->charpos))
 23812         {
 23813           int face_id = lookup_named_face (it->w, it->f, Qtrailing_whitespace, false);
 23814           if (face_id < 0)
 23815             return;
 23816 
 23817           if (!row->reversed_p)
 23818             {
 23819               while (glyph >= start
 23820                      && BUFFERP (glyph->object)
 23821                      && (glyph->type == STRETCH_GLYPH
 23822                          || (glyph->type == CHAR_GLYPH
 23823                              && glyph->u.ch == ' ')))
 23824                 (glyph--)->face_id = face_id;
 23825             }
 23826           else
 23827             {
 23828               while (glyph <= start
 23829                      && BUFFERP (glyph->object)
 23830                      && (glyph->type == STRETCH_GLYPH
 23831                          || (glyph->type == CHAR_GLYPH
 23832                              && glyph->u.ch == ' ')))
 23833                 (glyph++)->face_id = face_id;
 23834             }
 23835         }
 23836     }
 23837 }
 23838 
 23839 
 23840 /* Value is true if glyph row ROW should be
 23841    considered to hold the buffer position CHARPOS.  */
 23842 
 23843 static bool
 23844 row_for_charpos_p (struct glyph_row *row, ptrdiff_t charpos)
 23845 {
 23846   bool result = true;
 23847 
 23848   if (charpos == CHARPOS (row->end.pos)
 23849       || charpos == MATRIX_ROW_END_CHARPOS (row))
 23850     {
 23851       /* Suppose the row ends on a string.
 23852          Unless the row is continued, that means it ends on a newline
 23853          in the string.  If it's anything other than a display string
 23854          (e.g., a before-string from an overlay), we don't want the
 23855          cursor there.  (This heuristic seems to give the optimal
 23856          behavior for the various types of multi-line strings.)
 23857          One exception: if the string has `cursor' property on one of
 23858          its characters, we _do_ want the cursor there.  */
 23859       if (CHARPOS (row->end.string_pos) >= 0)
 23860         {
 23861           if (row->continued_p)
 23862             result = true;
 23863           else
 23864             {
 23865               /* Check for `display' property.  */
 23866               struct glyph *beg = row->glyphs[TEXT_AREA];
 23867               struct glyph *end = beg + row->used[TEXT_AREA] - 1;
 23868               struct glyph *glyph;
 23869 
 23870               result = false;
 23871               for (glyph = end; glyph >= beg; --glyph)
 23872                 if (STRINGP (glyph->object))
 23873                   {
 23874                     Lisp_Object prop
 23875                       = Fget_char_property (make_fixnum (charpos),
 23876                                             Qdisplay, Qnil);
 23877                     result =
 23878                       (!NILP (prop)
 23879                        && display_prop_string_p (prop, glyph->object));
 23880                     /* If there's a `cursor' property on one of the
 23881                        string's characters, this row is a cursor row,
 23882                        even though this is not a display string.  */
 23883                     if (!result)
 23884                       {
 23885                         Lisp_Object s = glyph->object;
 23886 
 23887                         for ( ; glyph >= beg && EQ (glyph->object, s); --glyph)
 23888                           {
 23889                             ptrdiff_t gpos = glyph->charpos;
 23890 
 23891                             if (!NILP (Fget_char_property (make_fixnum (gpos),
 23892                                                            Qcursor, s)))
 23893                               {
 23894                                 result = true;
 23895                                 break;
 23896                               }
 23897                           }
 23898                       }
 23899                     break;
 23900                   }
 23901             }
 23902         }
 23903       else if (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))
 23904         {
 23905           /* If the row ends in middle of a real character,
 23906              and the line is continued, we want the cursor here.
 23907              That's because CHARPOS (ROW->end.pos) would equal
 23908              PT if PT is before the character.  */
 23909           if (!row->ends_in_ellipsis_p)
 23910             result = row->continued_p;
 23911           else
 23912           /* If the row ends in an ellipsis, then
 23913              CHARPOS (ROW->end.pos) will equal point after the
 23914              invisible text.  We want that position to be displayed
 23915              after the ellipsis.  */
 23916             result = false;
 23917         }
 23918       /* If the row ends at ZV, display the cursor at the end of that
 23919          row instead of at the start of the row below.  */
 23920       else
 23921         result = row->ends_at_zv_p;
 23922     }
 23923 
 23924   return result;
 23925 }
 23926 
 23927 /* Value is true if glyph row ROW should be
 23928    used to hold the cursor.  */
 23929 
 23930 static bool
 23931 cursor_row_p (struct glyph_row *row)
 23932 {
 23933   return row_for_charpos_p (row, PT);
 23934 }
 23935 
 23936 
 23937 
 23938 /* Push the property PROP so that it will be rendered at the current
 23939    position in IT.  Return true if PROP was successfully pushed, false
 23940    otherwise.  Called from handle_line_prefix to handle the
 23941    `line-prefix' and `wrap-prefix' properties.  */
 23942 
 23943 static bool
 23944 push_prefix_prop (struct it *it, Lisp_Object prop)
 23945 {
 23946   struct text_pos pos =
 23947     STRINGP (it->string) ? it->current.string_pos : it->current.pos;
 23948 
 23949   eassert (it->method == GET_FROM_BUFFER
 23950            || it->method == GET_FROM_DISPLAY_VECTOR
 23951            || it->method == GET_FROM_STRING
 23952            || it->method == GET_FROM_IMAGE);
 23953 
 23954   /* We need to save the current buffer/string position, so it will be
 23955      restored by pop_it, because iterate_out_of_display_property
 23956      depends on that being set correctly, but some situations leave
 23957      it->position not yet set when this function is called.  */
 23958   push_it (it, &pos);
 23959 
 23960   if (STRINGP (prop))
 23961     {
 23962       if (SCHARS (prop) == 0)
 23963         {
 23964           pop_it (it);
 23965           return false;
 23966         }
 23967 
 23968       it->string = prop;
 23969       it->string_from_prefix_prop_p = true;
 23970       it->multibyte_p = STRING_MULTIBYTE (it->string);
 23971       it->current.overlay_string_index = -1;
 23972       IT_STRING_CHARPOS (*it) = IT_STRING_BYTEPOS (*it) = 0;
 23973       it->end_charpos = it->string_nchars = SCHARS (it->string);
 23974       it->method = GET_FROM_STRING;
 23975       it->stop_charpos = 0;
 23976       it->prev_stop = 0;
 23977       it->base_level_stop = 0;
 23978       it->cmp_it.id = -1;
 23979 
 23980       /* Force paragraph direction to be that of the parent
 23981          buffer/string.  */
 23982       if (it->bidi_p && it->bidi_it.paragraph_dir == R2L)
 23983         it->paragraph_embedding = it->bidi_it.paragraph_dir;
 23984       else
 23985         it->paragraph_embedding = L2R;
 23986 
 23987       /* Set up the bidi iterator for this display string.  */
 23988       if (it->bidi_p)
 23989         {
 23990           it->bidi_it.string.lstring = it->string;
 23991           it->bidi_it.string.s = NULL;
 23992           it->bidi_it.string.schars = it->end_charpos;
 23993           it->bidi_it.string.bufpos = IT_CHARPOS (*it);
 23994           it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
 23995           it->bidi_it.string.unibyte = !it->multibyte_p;
 23996           it->bidi_it.w = it->w;
 23997           bidi_init_it (0, 0, FRAME_WINDOW_P (it->f), &it->bidi_it);
 23998         }
 23999     }
 24000   else if (CONSP (prop) && EQ (XCAR (prop), Qspace))
 24001     {
 24002       it->method = GET_FROM_STRETCH;
 24003       it->object = prop;
 24004     }
 24005 #ifdef HAVE_WINDOW_SYSTEM
 24006   else if (IMAGEP (prop))
 24007     {
 24008       it->what = IT_IMAGE;
 24009       it->image_id = lookup_image (it->f, prop, it->face_id);
 24010       it->method = GET_FROM_IMAGE;
 24011     }
 24012 #endif /* HAVE_WINDOW_SYSTEM */
 24013   else
 24014     {
 24015       pop_it (it);              /* bogus display property, give up */
 24016       return false;
 24017     }
 24018 
 24019   return true;
 24020 }
 24021 
 24022 /* Return the character-property PROP at the current position in IT.  */
 24023 
 24024 static Lisp_Object
 24025 get_it_property (struct it *it, Lisp_Object prop)
 24026 {
 24027   Lisp_Object position, object = it->object;
 24028 
 24029   if (STRINGP (object))
 24030     position = make_fixnum (IT_STRING_CHARPOS (*it));
 24031   else if (BUFFERP (object))
 24032     {
 24033       position = make_fixnum (IT_CHARPOS (*it));
 24034       object = it->window;
 24035     }
 24036   else
 24037     return Qnil;
 24038 
 24039   return Fget_char_property (position, prop, object);
 24040 }
 24041 
 24042 /* Return the line-prefix/wrap-prefix property, checking both the
 24043    current IT->OBJECT and the underlying buffer text.  */
 24044 
 24045 static Lisp_Object
 24046 get_line_prefix_it_property (struct it *it, Lisp_Object prop)
 24047 {
 24048   Lisp_Object prefix = get_it_property (it, prop);
 24049 
 24050   /* If we are looking at a display or overlay string, check also the
 24051      underlying buffer text.  */
 24052   if (NILP (prefix) && it->sp > 0 && STRINGP (it->object))
 24053     return Fget_char_property (make_fixnum (IT_CHARPOS (*it)), prop,
 24054                                it->w->contents);
 24055   return prefix;
 24056 }
 24057 
 24058 /* See if there's a line- or wrap-prefix, and if so, push it on IT.  */
 24059 
 24060 static void
 24061 handle_line_prefix (struct it *it)
 24062 {
 24063   Lisp_Object prefix;
 24064 
 24065   if (it->continuation_lines_width > 0)
 24066     {
 24067       prefix = get_line_prefix_it_property (it, Qwrap_prefix);
 24068       if (NILP (prefix))
 24069         prefix = Vwrap_prefix;
 24070     }
 24071   else
 24072     {
 24073       prefix = get_line_prefix_it_property (it, Qline_prefix);
 24074       if (NILP (prefix))
 24075         prefix = Vline_prefix;
 24076     }
 24077   if (! NILP (prefix) && push_prefix_prop (it, prefix))
 24078     {
 24079       /* If the prefix is wider than the window, and we try to wrap
 24080          it, it would acquire its own wrap prefix, and so on till the
 24081          iterator stack overflows.  So, don't wrap the prefix.  */
 24082       it->line_wrap = TRUNCATE;
 24083       it->avoid_cursor_p = true;
 24084     }
 24085 }
 24086 
 24087 
 24088 
 24089 /* Remove N glyphs at the start of a reversed IT->glyph_row.  Called
 24090    only for R2L lines from display_line and display_string, when they
 24091    decide that too many glyphs were produced by PRODUCE_GLYPHS, and
 24092    the line/string needs to be continued on the next glyph row.  */
 24093 static void
 24094 unproduce_glyphs (struct it *it, int n)
 24095 {
 24096   struct glyph *glyph, *end;
 24097 
 24098   eassert (it->glyph_row);
 24099   eassert (it->glyph_row->reversed_p);
 24100   eassert (it->area == TEXT_AREA);
 24101   eassert (n <= it->glyph_row->used[TEXT_AREA]);
 24102 
 24103   if (n > it->glyph_row->used[TEXT_AREA])
 24104     n = it->glyph_row->used[TEXT_AREA];
 24105   glyph = it->glyph_row->glyphs[TEXT_AREA] + n;
 24106   end = it->glyph_row->glyphs[TEXT_AREA] + it->glyph_row->used[TEXT_AREA];
 24107   for ( ; glyph < end; glyph++)
 24108     glyph[-n] = *glyph;
 24109 }
 24110 
 24111 /* Find the positions in a bidi-reordered ROW to serve as ROW->minpos
 24112    and ROW->maxpos.  */
 24113 static void
 24114 find_row_edges (struct it *it, struct glyph_row *row,
 24115                 ptrdiff_t min_pos, ptrdiff_t min_bpos,
 24116                 ptrdiff_t max_pos, ptrdiff_t max_bpos)
 24117 {
 24118   /* FIXME: Revisit this when glyph ``spilling'' in continuation
 24119      lines' rows is implemented for bidi-reordered rows.  */
 24120 
 24121   /* ROW->minpos is the value of min_pos, the minimal buffer position
 24122      we have in ROW, or ROW->start.pos if that is smaller.  */
 24123   if (min_pos <= ZV && min_pos < row->start.pos.charpos)
 24124     SET_TEXT_POS (row->minpos, min_pos, min_bpos);
 24125   else
 24126     /* We didn't find buffer positions smaller than ROW->start, or
 24127        didn't find _any_ valid buffer positions in any of the glyphs,
 24128        so we must trust the iterator's computed positions.  */
 24129       row->minpos = row->start.pos;
 24130   if (max_pos <= 0)
 24131     {
 24132       max_pos = CHARPOS (it->current.pos);
 24133       max_bpos = BYTEPOS (it->current.pos);
 24134     }
 24135 
 24136   /* Here are the various use-cases for ending the row, and the
 24137      corresponding values for ROW->maxpos:
 24138 
 24139      Line ends in a newline from buffer       eol_pos + 1
 24140      Line is continued from buffer            max_pos + 1
 24141      Line is truncated on right               it->current.pos
 24142      Line ends in a newline from string       max_pos + 1(*)
 24143       (*) + 1 only when line ends in a forward scan
 24144      Line is continued from string            max_pos
 24145      Line is continued from display vector    max_pos
 24146      Line is entirely from a string           min_pos == max_pos
 24147      Line is entirely from a display vector   min_pos == max_pos
 24148      Line that ends at ZV                     ZV
 24149 
 24150      If you discover other use-cases, please add them here as
 24151      appropriate.  */
 24152   if (row->ends_at_zv_p)
 24153     row->maxpos = it->current.pos;
 24154   else if (row->used[TEXT_AREA])
 24155     {
 24156       bool seen_this_string = false;
 24157       struct glyph_row *r1 = row - 1;
 24158 
 24159       /* Did we see the same display string on the previous row?  */
 24160       if (STRINGP (it->object)
 24161           /* this is not the first row */
 24162           && row > it->w->desired_matrix->rows
 24163           /* previous row is not the header line or tab-line */
 24164           && !r1->mode_line_p
 24165           /* previous row also ends in a newline from a string */
 24166           && r1->ends_in_newline_from_string_p)
 24167         {
 24168           struct glyph *start, *end;
 24169 
 24170           /* Search for the last glyph of the previous row that came
 24171              from buffer or string.  Depending on whether the row is
 24172              L2R or R2L, we need to process it front to back or the
 24173              other way round.  */
 24174           if (!r1->reversed_p)
 24175             {
 24176               start = r1->glyphs[TEXT_AREA];
 24177               end = start + r1->used[TEXT_AREA];
 24178               /* Glyphs inserted by redisplay have nil as their object.  */
 24179               while (end > start
 24180                      && NILP ((end - 1)->object)
 24181                      && (end - 1)->charpos <= 0)
 24182                 --end;
 24183               if (end > start)
 24184                 {
 24185                   if (EQ ((end - 1)->object, it->object))
 24186                     seen_this_string = true;
 24187                 }
 24188               else
 24189                 /* If all the glyphs of the previous row were inserted
 24190                    by redisplay, it means the previous row was
 24191                    produced from a single newline, which is only
 24192                    possible if that newline came from the same string
 24193                    as the one which produced this ROW.  */
 24194                 seen_this_string = true;
 24195             }
 24196           else
 24197             {
 24198               end = r1->glyphs[TEXT_AREA] - 1;
 24199               start = end + r1->used[TEXT_AREA];
 24200               while (end < start
 24201                      && NILP ((end + 1)->object)
 24202                      && (end + 1)->charpos <= 0)
 24203                 ++end;
 24204               if (end < start)
 24205                 {
 24206                   if (EQ ((end + 1)->object, it->object))
 24207                     seen_this_string = true;
 24208                 }
 24209               else
 24210                 seen_this_string = true;
 24211             }
 24212         }
 24213       /* Take note of each display string that covers a newline only
 24214          once, the first time we see it.  This is for when a display
 24215          string includes more than one newline in it.  */
 24216       if (row->ends_in_newline_from_string_p && !seen_this_string)
 24217         {
 24218           /* If we were scanning the buffer forward when we displayed
 24219              the string, we want to account for at least one buffer
 24220              position that belongs to this row (position covered by
 24221              the display string), so that cursor positioning will
 24222              consider this row as a candidate when point is at the end
 24223              of the visual line represented by this row.  This is not
 24224              required when scanning back, because max_pos will already
 24225              have a much larger value.  */
 24226           if (CHARPOS (row->end.pos) > max_pos)
 24227             inc_both (&max_pos, &max_bpos);
 24228           SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
 24229         }
 24230       else if (CHARPOS (it->eol_pos) > 0)
 24231         SET_TEXT_POS (row->maxpos,
 24232                       CHARPOS (it->eol_pos) + 1, BYTEPOS (it->eol_pos) + 1);
 24233       else if (row->continued_p)
 24234         {
 24235           /* If max_pos is different from IT's current position, it
 24236              means IT->method does not belong to the display element
 24237              at max_pos.  However, it also means that the display
 24238              element at max_pos was displayed in its entirety on this
 24239              line, which is equivalent to saying that the next line
 24240              starts at the next buffer position.  */
 24241           if (IT_CHARPOS (*it) == max_pos && it->method != GET_FROM_BUFFER)
 24242             SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
 24243           else
 24244             {
 24245               inc_both (&max_pos, &max_bpos);
 24246               SET_TEXT_POS (row->maxpos, max_pos, max_bpos);
 24247             }
 24248         }
 24249       else if (row->truncated_on_right_p)
 24250         /* display_line already called reseat_at_next_visible_line_start,
 24251            which puts the iterator at the beginning of the next line, in
 24252            the logical order. */
 24253         row->maxpos = it->current.pos;
 24254       else if (max_pos == min_pos && it->method != GET_FROM_BUFFER)
 24255         /* A line that is entirely from a string/image/stretch...  */
 24256         row->maxpos = row->minpos;
 24257       else
 24258         emacs_abort ();
 24259     }
 24260   else
 24261     row->maxpos = it->current.pos;
 24262 }
 24263 
 24264 /* Like display_count_lines, but capable of counting outside of the
 24265    current narrowed region.  */
 24266 static ptrdiff_t
 24267 display_count_lines_logically (ptrdiff_t start_byte, ptrdiff_t limit_byte,
 24268                                ptrdiff_t count, ptrdiff_t *byte_pos_ptr)
 24269 {
 24270   if (!display_line_numbers_widen || (BEGV == BEG && ZV == Z))
 24271     return display_count_lines (start_byte, limit_byte, count, byte_pos_ptr);
 24272 
 24273   ptrdiff_t val;
 24274   specpdl_ref pdl_count = SPECPDL_INDEX ();
 24275   record_unwind_protect (save_restriction_restore, save_restriction_save ());
 24276   labeled_restrictions_remove_in_current_buffer ();
 24277   Fwiden ();
 24278   val = display_count_lines (start_byte, limit_byte, count, byte_pos_ptr);
 24279   unbind_to (pdl_count, Qnil);
 24280   return val;
 24281 }
 24282 
 24283 /* Count the number of screen lines in window IT->w between character
 24284    position IT_CHARPOS(*IT) and the line showing that window's point.  */
 24285 static ptrdiff_t
 24286 display_count_lines_visually (struct it *it)
 24287 {
 24288   struct it tem_it;
 24289   ptrdiff_t to;
 24290   struct text_pos from;
 24291 
 24292   /* If we already calculated a relative line number, use that.  This
 24293      trick relies on the fact that visual lines (a.k.a. "glyph rows")
 24294      are laid out sequentially, one by one, for each sequence of calls
 24295      to display_line or other similar function that follows a call to
 24296      init_iterator.  */
 24297   if (it->lnum_bytepos > 0)
 24298     return it->lnum + 1;
 24299   else
 24300     {
 24301       specpdl_ref count = SPECPDL_INDEX ();
 24302 
 24303       if (IT_CHARPOS (*it) <= PT)
 24304         {
 24305           from = it->current.pos;
 24306           to = PT;
 24307         }
 24308       else
 24309         {
 24310           SET_TEXT_POS (from, PT, PT_BYTE);
 24311           to = IT_CHARPOS (*it);
 24312         }
 24313       /* Need to disable visual mode temporarily, since otherwise the
 24314          call to move_it_to below and inside start_display will cause
 24315          infinite recursion.  */
 24316       specbind (Qdisplay_line_numbers, Qrelative);
 24317       start_display (&tem_it, it->w, from);
 24318       /* Some redisplay optimizations could invoke us very far from
 24319          PT, which will make the caller painfully slow.  There should
 24320          be no need to go too far beyond the window's bottom, as any
 24321          such optimization will fail to show point anyway.  */
 24322       move_it_to (&tem_it, to, -1,
 24323                   tem_it.last_visible_y
 24324                   + (SCROLL_LIMIT + 10) * FRAME_LINE_HEIGHT (tem_it.f),
 24325                   -1, MOVE_TO_POS | MOVE_TO_Y);
 24326       unbind_to (count, Qnil);
 24327       return IT_CHARPOS (*it) <= PT ? -tem_it.vpos : tem_it.vpos;
 24328     }
 24329 }
 24330 
 24331 /* Produce the line-number glyphs for the current glyph_row.  If
 24332    IT->glyph_row is non-NULL, populate the row with the produced
 24333    glyphs.  */
 24334 static void
 24335 maybe_produce_line_number (struct it *it)
 24336 {
 24337   ptrdiff_t last_line = it->lnum;
 24338   ptrdiff_t start_from, bytepos;
 24339   ptrdiff_t this_line;
 24340   bool first_time = false;
 24341   ptrdiff_t beg_byte;
 24342   ptrdiff_t z_byte;
 24343   bool line_numbers_wide;
 24344   void *itdata = bidi_shelve_cache ();
 24345 
 24346   if (display_line_numbers_offset
 24347       && !display_line_numbers_widen
 24348       && !EQ (Vdisplay_line_numbers, Qvisual)
 24349       && !EQ (Vdisplay_line_numbers, Qrelative))
 24350     line_numbers_wide = true;
 24351   else
 24352     line_numbers_wide = display_line_numbers_widen;
 24353 
 24354   beg_byte = line_numbers_wide ? BEG_BYTE : BEGV_BYTE;
 24355   z_byte = line_numbers_wide ? Z_BYTE : ZV_BYTE;
 24356 
 24357   if (EQ (Vdisplay_line_numbers, Qvisual))
 24358     this_line = display_count_lines_visually (it);
 24359   else
 24360     {
 24361       if (!last_line)
 24362         {
 24363           /* If possible, reuse data cached by line-number-mode.  */
 24364           if (it->w->base_line_number > 0
 24365               && it->w->base_line_pos > 0
 24366               && it->w->base_line_pos <= IT_CHARPOS (*it)
 24367               /* line-number-mode always displays narrowed line
 24368                  numbers, so we cannot use its data if the user wants
 24369                  line numbers that disregard narrowing, or if the
 24370                  buffer's narrowing has just changed.  */
 24371               && !(line_numbers_wide
 24372                    && (BEG_BYTE != BEGV_BYTE || Z_BYTE != ZV_BYTE))
 24373               && !current_buffer->clip_changed)
 24374             {
 24375               start_from = CHAR_TO_BYTE (it->w->base_line_pos);
 24376               last_line = it->w->base_line_number - 1;
 24377             }
 24378           else
 24379             start_from = beg_byte;
 24380           if (!it->lnum_bytepos)
 24381             first_time = true;
 24382         }
 24383       else
 24384         start_from = it->lnum_bytepos;
 24385 
 24386       /* Paranoia: what if someone changes the narrowing since the
 24387          last time display_line was called?  Shouldn't really happen,
 24388          but who knows what some crazy Lisp invoked by :eval could do?  */
 24389       if (!(beg_byte <= start_from && start_from <= z_byte))
 24390         {
 24391           last_line = 0;
 24392           start_from = beg_byte;
 24393         }
 24394 
 24395       this_line =
 24396         last_line + display_count_lines_logically (start_from,
 24397                                                    IT_BYTEPOS (*it),
 24398                                                    IT_CHARPOS (*it), &bytepos);
 24399       eassert (this_line > 0 || (this_line == 0 && start_from == beg_byte));
 24400       eassert (bytepos == IT_BYTEPOS (*it));
 24401     }
 24402 
 24403   /* Record the line number information.  */
 24404   if (this_line != last_line || !it->lnum_bytepos)
 24405     {
 24406       it->lnum = this_line;
 24407       it->lnum_bytepos = IT_BYTEPOS (*it);
 24408     }
 24409 
 24410   /* Produce the glyphs for the line number.  */
 24411   struct it tem_it;
 24412   char lnum_buf[INT_STRLEN_BOUND (ptrdiff_t) + 1];
 24413   bool beyond_zv = IT_BYTEPOS (*it) >= ZV_BYTE ? true : false;
 24414   ptrdiff_t lnum_offset = -1; /* to produce 1-based line numbers */
 24415   int lnum_face_id = merge_faces (it->w, Qline_number, 0, DEFAULT_FACE_ID);
 24416   int current_lnum_face_id
 24417     = merge_faces (it->w, Qline_number_current_line, 0, DEFAULT_FACE_ID);
 24418   /* From here onwards, we must prevent freeing realized faces, because
 24419      we are using the above 2 face IDs for the glyphs we produce.  */
 24420   bool save_free_realized_faces = inhibit_free_realized_faces;
 24421   inhibit_free_realized_faces = true;
 24422   /* Compute point's line number if needed.  */
 24423   if ((EQ (Vdisplay_line_numbers, Qrelative)
 24424        || EQ (Vdisplay_line_numbers, Qvisual)
 24425        || lnum_face_id != current_lnum_face_id)
 24426       && !it->pt_lnum)
 24427     {
 24428       ptrdiff_t ignored;
 24429       if (PT_BYTE > it->lnum_bytepos && !EQ (Vdisplay_line_numbers, Qvisual))
 24430         it->pt_lnum =
 24431           this_line + display_count_lines_logically (it->lnum_bytepos, PT_BYTE,
 24432                                                      PT, &ignored);
 24433       else
 24434         it->pt_lnum = display_count_lines_logically (beg_byte, PT_BYTE, PT,
 24435                                                      &ignored);
 24436     }
 24437   /* Compute the required width if needed.  */
 24438   if (!it->lnum_width)
 24439     {
 24440       if (FIXNATP (Vdisplay_line_numbers_width))
 24441         it->lnum_width = XFIXNAT (Vdisplay_line_numbers_width);
 24442 
 24443       /* Max line number to be displayed cannot be more than the one
 24444          corresponding to the last row of the desired matrix.  */
 24445       ptrdiff_t max_lnum;
 24446 
 24447       if (NILP (Vdisplay_line_numbers_current_absolute)
 24448           && (EQ (Vdisplay_line_numbers, Qrelative)
 24449               || EQ (Vdisplay_line_numbers, Qvisual)))
 24450         /* We subtract one more because the current line is always
 24451            zero in this mode.  */
 24452         max_lnum = it->w->desired_matrix->nrows - 2;
 24453       else if (EQ (Vdisplay_line_numbers, Qvisual))
 24454         max_lnum = it->pt_lnum + it->w->desired_matrix->nrows - 1;
 24455       else
 24456         max_lnum = this_line + it->w->desired_matrix->nrows - 1 - it->vpos;
 24457       max_lnum = max (1, max_lnum);
 24458       it->lnum_width = max (it->lnum_width, log10 (max_lnum) + 1);
 24459       eassert (it->lnum_width > 0);
 24460     }
 24461   if (EQ (Vdisplay_line_numbers, Qrelative))
 24462     lnum_offset = it->pt_lnum;
 24463   else if (EQ (Vdisplay_line_numbers, Qvisual))
 24464     lnum_offset = 0;
 24465   else if (display_line_numbers_offset)
 24466     lnum_offset -= display_line_numbers_offset;
 24467 
 24468   /* Under 'relative', display the absolute line number for the
 24469      current line, unless the user requests otherwise.  */
 24470   ptrdiff_t lnum_to_display = eabs (this_line - lnum_offset);
 24471   if ((EQ (Vdisplay_line_numbers, Qrelative)
 24472        || EQ (Vdisplay_line_numbers, Qvisual))
 24473       && lnum_to_display == 0
 24474       && !NILP (Vdisplay_line_numbers_current_absolute))
 24475     lnum_to_display = it->pt_lnum + 1;
 24476   /* In L2R rows we need to append the blank separator, in R2L
 24477      rows we need to prepend it.  But this function is usually
 24478      called when no display elements were produced from the
 24479      following line, so the paragraph direction might be unknown.
 24480      Therefore we cheat and add 2 blanks, one on either side.  */
 24481   pint2str (lnum_buf, it->lnum_width + 1, lnum_to_display);
 24482   strcat (lnum_buf, " ");
 24483 
 24484   /* Setup for producing the glyphs.  */
 24485   init_iterator (&tem_it, it->w, -1, -1, &scratch_glyph_row,
 24486                  /* FIXME: Use specialized face.  */
 24487                  DEFAULT_FACE_ID);
 24488   scratch_glyph_row.reversed_p = false;
 24489   scratch_glyph_row.used[TEXT_AREA] = 0;
 24490   SET_TEXT_POS (tem_it.position, 0, 0);
 24491   tem_it.avoid_cursor_p = true;
 24492   tem_it.bidi_p = true;
 24493   tem_it.bidi_it.type = WEAK_EN;
 24494   /* According to UAX#9, EN goes up 2 levels in L2R paragraph and
 24495      1 level in R2L paragraphs.  Emulate that, assuming we are in
 24496      an L2R paragraph.  */
 24497   tem_it.bidi_it.resolved_level = 2;
 24498 
 24499   /* We must leave space for 2 glyphs for continuation and truncation,
 24500      and at least one glyph for buffer text.  */
 24501   int width_limit =
 24502     tem_it.last_visible_x - tem_it.first_visible_x
 24503     - 3 * FRAME_COLUMN_WIDTH (it->f);
 24504 
 24505   tem_it.face_id = lnum_face_id;
 24506   /* Avoid displaying any face other than line-number on
 24507      empty lines beyond EOB.  */
 24508   if (lnum_face_id != current_lnum_face_id
 24509       && (EQ (Vdisplay_line_numbers, Qvisual)
 24510           ? this_line == 0
 24511           : this_line == it->pt_lnum)
 24512       && it->what != IT_EOB)
 24513     tem_it.face_id = current_lnum_face_id;
 24514   else if (!beyond_zv)
 24515     {
 24516       if (display_line_numbers_major_tick > 0
 24517           && (lnum_to_display % display_line_numbers_major_tick == 0))
 24518         tem_it.face_id = merge_faces (it->w, Qline_number_major_tick,
 24519                                       0, DEFAULT_FACE_ID);
 24520       else if (display_line_numbers_minor_tick > 0
 24521                && (lnum_to_display % display_line_numbers_minor_tick == 0))
 24522         tem_it.face_id = merge_faces (it->w, Qline_number_minor_tick,
 24523                                       0, DEFAULT_FACE_ID);
 24524     }
 24525 
 24526   /* Produce glyphs for the line number in a scratch glyph_row.  */
 24527   for (const char *p = lnum_buf; *p; p++)
 24528     {
 24529       /* For continuation lines and lines after ZV, instead of a line
 24530          number, produce a blank prefix of the same width.  */
 24531       if (beyond_zv
 24532           /* Don't display the same line number more than once.  */
 24533           || (!EQ (Vdisplay_line_numbers, Qvisual)
 24534               && (it->continuation_lines_width > 0
 24535                   || (this_line == last_line && !first_time))))
 24536         tem_it.c = tem_it.char_to_display = ' ';
 24537       else
 24538         tem_it.c = tem_it.char_to_display = *p;
 24539       tem_it.len = 1;
 24540       /* Make sure these glyphs will have a "position" of -1.  */
 24541       SET_TEXT_POS (tem_it.position, -1, -1);
 24542       PRODUCE_GLYPHS (&tem_it);
 24543 
 24544       /* Stop producing glyphs, and refrain from producing the line
 24545          number, if we don't have enough space on this line.  */
 24546       if (tem_it.current_x >= width_limit)
 24547         {
 24548           it->lnum_width = 0;
 24549           it->lnum_pixel_width = 0;
 24550           bidi_unshelve_cache (itdata, false);
 24551           inhibit_free_realized_faces = save_free_realized_faces;
 24552           return;
 24553         }
 24554     }
 24555 
 24556   inhibit_free_realized_faces = save_free_realized_faces;
 24557 
 24558   /* Record the width in pixels we need for the line number display.  */
 24559   it->lnum_pixel_width = tem_it.current_x;
 24560   /* Copy the produced glyphs into IT's glyph_row.  */
 24561   struct glyph *g = scratch_glyph_row.glyphs[TEXT_AREA];
 24562   struct glyph *e = g + scratch_glyph_row.used[TEXT_AREA];
 24563   struct glyph *p = it->glyph_row ? it->glyph_row->glyphs[TEXT_AREA] : NULL;
 24564   short *u = it->glyph_row ? &it->glyph_row->used[TEXT_AREA] : NULL;
 24565 
 24566   eassert (it->glyph_row == NULL || it->glyph_row->used[TEXT_AREA] == 0);
 24567 
 24568   for ( ; g < e; g++)
 24569     {
 24570       it->current_x += g->pixel_width;
 24571       /* The following is important when this function is called
 24572          from move_it_in_display_line_to: HPOS is incremented only
 24573          when we are in the visible portion of the glyph row.  */
 24574       if (it->current_x > it->first_visible_x)
 24575         it->hpos++;
 24576       if (p)
 24577         {
 24578           *p++ = *g;
 24579           (*u)++;
 24580         }
 24581     }
 24582 
 24583   /* Update IT's metrics due to glyphs produced for line numbers.
 24584      Don't do that for rows beyond ZV, to avoid displaying a cursor of
 24585      different dimensions there.  */
 24586   if (!beyond_zv)
 24587     {
 24588       if (it->glyph_row)
 24589         {
 24590           struct glyph_row *row = it->glyph_row;
 24591 
 24592           it->max_ascent = max (row->ascent, tem_it.max_ascent);
 24593           it->max_descent = max (row->height - row->ascent, tem_it.max_descent);
 24594           it->max_phys_ascent = max (row->phys_ascent, tem_it.max_phys_ascent);
 24595           it->max_phys_descent = max (row->phys_height - row->phys_ascent,
 24596                                       tem_it.max_phys_descent);
 24597         }
 24598       else
 24599         {
 24600           it->max_ascent = max (it->max_ascent, tem_it.max_ascent);
 24601           it->max_descent = max (it->max_descent, tem_it.max_descent);
 24602           it->max_phys_ascent = max (it->max_phys_ascent,
 24603                                      tem_it.max_phys_ascent);
 24604           it->max_phys_descent = max (it->max_phys_descent,
 24605                                       tem_it.max_phys_descent);
 24606         }
 24607     }
 24608 
 24609   it->line_number_produced_p = true;
 24610 
 24611   bidi_unshelve_cache (itdata, false);
 24612 }
 24613 
 24614 /* Return true if this glyph row needs a line number to be produced
 24615    for it.  */
 24616 static bool
 24617 should_produce_line_number (struct it *it)
 24618 {
 24619   if (NILP (Vdisplay_line_numbers))
 24620     return false;
 24621 
 24622   /* Don't display line numbers in minibuffer windows.  */
 24623   if (MINI_WINDOW_P (it->w))
 24624     return false;
 24625 
 24626 #ifdef HAVE_WINDOW_SYSTEM
 24627   /* Don't display line number in tooltip frames.  */
 24628   if (FRAME_TOOLTIP_P (XFRAME (WINDOW_FRAME (it->w))))
 24629     return false;
 24630 #endif
 24631 
 24632   /* If the character at current position has a non-nil special
 24633      property, disable line numbers for this row.  This is for
 24634      packages such as company-mode, which need this for their tricky
 24635      layout, where line numbers get in the way.  */
 24636   Lisp_Object val = Fget_char_property (make_fixnum (IT_CHARPOS (*it)),
 24637                                         Qdisplay_line_numbers_disable,
 24638                                         it->window);
 24639   /* For ZV, we need to also look in empty overlays at that point,
 24640      because get-char-property always returns nil for ZV, except if
 24641      the property is in 'default-text-properties'.  */
 24642   if (NILP (val) && IT_CHARPOS (*it) >= ZV)
 24643     val = disable_line_numbers_overlay_at_eob ();
 24644   return NILP (val) ? true : false;
 24645 }
 24646 
 24647 /* Return true if ROW has no glyphs except those inserted by the
 24648    display engine.  This is needed for indicate-empty-lines and
 24649    similar features when the glyph row starts with glyphs which didn't
 24650    come from buffer or string.  */
 24651 static bool
 24652 row_text_area_empty (struct glyph_row *row)
 24653 {
 24654   if (!row->reversed_p)
 24655     {
 24656       for (struct glyph *g = row->glyphs[TEXT_AREA];
 24657            g < row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 24658            g++)
 24659         if (!NILP (g->object) || g->charpos > 0)
 24660           return false;
 24661     }
 24662   else
 24663     {
 24664       for (struct glyph *g = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 24665            g > row->glyphs[TEXT_AREA];
 24666            g--)
 24667         if (!NILP ((g - 1)->object) || (g - 1)->charpos > 0)
 24668           return false;
 24669     }
 24670 
 24671   return true;
 24672 }
 24673 
 24674 /* Construct the glyph row IT->glyph_row in the desired matrix of
 24675    IT->w from text at the current position of IT.  See dispextern.h
 24676    for an overview of struct it.  Value is true if
 24677    IT->glyph_row displays text, as opposed to a line displaying ZV
 24678    only.  CURSOR_VPOS is the window-relative vertical position of
 24679    the glyph row displaying the cursor, or -1 if unknown.  */
 24680 
 24681 static bool
 24682 display_line (struct it *it, int cursor_vpos)
 24683 {
 24684   struct glyph_row *row = it->glyph_row;
 24685   Lisp_Object overlay_arrow_string;
 24686   struct it wrap_it;
 24687   void *wrap_data = NULL;
 24688   bool may_wrap = false;
 24689   int wrap_x UNINIT;
 24690   int wrap_row_used = -1;
 24691   int wrap_row_ascent UNINIT, wrap_row_height UNINIT;
 24692   int wrap_row_phys_ascent UNINIT, wrap_row_phys_height UNINIT;
 24693   int wrap_row_extra_line_spacing UNINIT;
 24694   ptrdiff_t wrap_row_min_pos UNINIT, wrap_row_min_bpos UNINIT;
 24695   ptrdiff_t wrap_row_max_pos UNINIT, wrap_row_max_bpos UNINIT;
 24696   int cvpos;
 24697   ptrdiff_t min_pos = ZV + 1, max_pos = 0;
 24698   ptrdiff_t min_bpos UNINIT, max_bpos UNINIT;
 24699   bool pending_handle_line_prefix = false;
 24700   int tab_line = window_wants_tab_line (it->w);
 24701   int header_line = window_wants_header_line (it->w);
 24702   bool hscroll_this_line = (cursor_vpos >= 0
 24703                             && it->vpos == cursor_vpos - tab_line - header_line
 24704                             && hscrolling_current_line_p (it->w));
 24705   int first_visible_x = it->first_visible_x;
 24706   int last_visible_x = it->last_visible_x;
 24707   int x_incr = 0;
 24708 
 24709   /* We always start displaying at hpos zero even if hscrolled.  */
 24710   eassert (it->hpos == 0 && it->current_x == 0);
 24711 
 24712   if (MATRIX_ROW_VPOS (row, it->w->desired_matrix)
 24713       >= it->w->desired_matrix->nrows)
 24714     {
 24715       it->w->nrows_scale_factor++;
 24716       it->f->fonts_changed = true;
 24717       return false;
 24718     }
 24719 
 24720   /* Clear the result glyph row and enable it.  */
 24721   prepare_desired_row (it->w, row, false);
 24722 
 24723   row->y = it->current_y;
 24724   row->start = it->start;
 24725   row->continuation_lines_width = it->continuation_lines_width;
 24726   row->displays_text_p = true;
 24727   row->starts_in_middle_of_char_p = it->starts_in_middle_of_char_p;
 24728   it->starts_in_middle_of_char_p = false;
 24729   it->stretch_adjust = 0;
 24730   it->line_number_produced_p = false;
 24731 
 24732   /* If we are going to display the cursor's line, account for the
 24733      hscroll of that line.  We subtract the window's min_hscroll,
 24734      because that was already accounted for in init_iterator.  */
 24735   if (hscroll_this_line)
 24736     x_incr =
 24737       (window_hscroll_limited (it->w, it->f) - it->w->min_hscroll)
 24738       * FRAME_COLUMN_WIDTH (it->f);
 24739 
 24740   bool line_number_needed = should_produce_line_number (it);
 24741 
 24742   /* Move over display elements that are not visible because we are
 24743      hscrolled.  This may stop at an x-position < first_visible_x
 24744      if the first glyph is partially visible or if we hit a line end.  */
 24745   if (it->current_x < it->first_visible_x + x_incr)
 24746     {
 24747       enum move_it_result move_result;
 24748 
 24749       this_line_min_pos = row->start.pos;
 24750       if (hscroll_this_line)
 24751         {
 24752           it->first_visible_x += x_incr;
 24753           it->last_visible_x  += x_incr;
 24754         }
 24755       if (current_buffer->long_line_optimizations_p
 24756           && it->line_wrap == TRUNCATE
 24757           && window_hscroll_limited (it->w, it->f) > large_hscroll_threshold)
 24758         {
 24759           /* Special optimization for very long and truncated lines
 24760              which are hscrolled far to the left: jump directly to the
 24761              (approximate) position that is visible, instead of slowly
 24762              walking there.  */
 24763           ptrdiff_t chars_to_skip =
 24764             it->first_visible_x / FRAME_COLUMN_WIDTH (it->f);
 24765           move_result = fast_move_it_horizontally (it, chars_to_skip);
 24766 
 24767           if (move_result == MOVE_X_REACHED)
 24768             it->current_x = it->first_visible_x;
 24769           else  /* use arbitrary value < first_visible_x */
 24770             it->current_x = it->first_visible_x - FRAME_COLUMN_WIDTH (it->f);
 24771         }
 24772       else
 24773         move_result = move_it_in_display_line_to (it, ZV, it->first_visible_x,
 24774                                                   MOVE_TO_POS | MOVE_TO_X);
 24775       /* If we are under a large hscroll, move_it_in_display_line_to
 24776          could hit the end of the line without reaching
 24777          first_visible_x.  Pretend that we did reach it.  This is
 24778          especially important on a TTY, where we will call
 24779          extend_face_to_end_of_line, which needs to know how many
 24780          blank glyphs to produce.  */
 24781       if (it->current_x < it->first_visible_x
 24782           && (move_result == MOVE_NEWLINE_OR_CR
 24783               || move_result == MOVE_POS_MATCH_OR_ZV))
 24784         it->current_x = it->first_visible_x;
 24785 
 24786       /* In case move_it_in_display_line_to above "produced" the line
 24787          number.  */
 24788       it->line_number_produced_p = false;
 24789 
 24790       /* Record the smallest positions seen while we moved over
 24791          display elements that are not visible.  This is needed by
 24792          redisplay_internal for optimizing the case where the cursor
 24793          stays inside the same line.  The rest of this function only
 24794          considers positions that are actually displayed, so
 24795          RECORD_MAX_MIN_POS will not otherwise record positions that
 24796          are hscrolled to the left of the left edge of the window.  */
 24797       min_pos = CHARPOS (this_line_min_pos);
 24798       min_bpos = BYTEPOS (this_line_min_pos);
 24799 
 24800       /* Produce line number, if needed.  */
 24801       if (line_number_needed)
 24802         maybe_produce_line_number (it);
 24803     }
 24804   else if (it->area == TEXT_AREA)
 24805     {
 24806       /* Line numbers should precede the line-prefix or wrap-prefix.  */
 24807       if (line_number_needed)
 24808         maybe_produce_line_number (it);
 24809 
 24810       /* We only do this when not calling move_it_in_display_line_to
 24811          above, because that function calls itself handle_line_prefix.  */
 24812       handle_line_prefix (it);
 24813     }
 24814   else
 24815     {
 24816       /* Line-prefix and wrap-prefix are always displayed in the text
 24817          area.  But if this is the first call to display_line after
 24818          init_iterator, the iterator might have been set up to write
 24819          into a marginal area, e.g. if the line begins with some
 24820          display property that writes to the margins.  So we need to
 24821          wait with the call to handle_line_prefix until whatever
 24822          writes to the margin has done its job.  */
 24823       pending_handle_line_prefix = true;
 24824     }
 24825 
 24826   /* Get the initial row height.  This is either the height of the
 24827      text hscrolled, if there is any, or zero.  */
 24828   row->ascent = it->max_ascent;
 24829   row->height = it->max_ascent + it->max_descent;
 24830   row->phys_ascent = it->max_phys_ascent;
 24831   row->phys_height = it->max_phys_ascent + it->max_phys_descent;
 24832   row->extra_line_spacing = it->max_extra_line_spacing;
 24833 
 24834 /* Utility macro to record max and min buffer positions seen until now.  */
 24835 #define RECORD_MAX_MIN_POS(IT)                                  \
 24836   do                                                            \
 24837     {                                                           \
 24838       bool composition_p                                        \
 24839         = !STRINGP ((IT)->string) && ((IT)->what == IT_COMPOSITION); \
 24840       ptrdiff_t current_pos =                                   \
 24841         composition_p ? (IT)->cmp_it.charpos                    \
 24842                       : IT_CHARPOS (*(IT));                     \
 24843       ptrdiff_t current_bpos =                                  \
 24844         composition_p ? CHAR_TO_BYTE (current_pos)              \
 24845                       : IT_BYTEPOS (*(IT));                     \
 24846       if (current_pos < min_pos)                                \
 24847         {                                                       \
 24848           min_pos = current_pos;                                \
 24849           min_bpos = current_bpos;                              \
 24850         }                                                       \
 24851       if (IT_CHARPOS (*it) > max_pos)                           \
 24852         {                                                       \
 24853           max_pos = IT_CHARPOS (*it);                           \
 24854           max_bpos = IT_BYTEPOS (*it);                          \
 24855         }                                                       \
 24856     }                                                           \
 24857   while (false)
 24858 
 24859   /* Loop generating characters.  The loop is left with IT on the next
 24860      character to display.  */
 24861   while (true)
 24862     {
 24863       int n_glyphs_before, hpos_before, x_before;
 24864       int x, nglyphs;
 24865       int ascent = 0, descent = 0, phys_ascent = 0, phys_descent = 0;
 24866 
 24867       /* Retrieve the next thing to display.  Value is false if end of
 24868          buffer reached.  */
 24869       if (!get_next_display_element (it))
 24870         {
 24871           bool row_has_glyphs = false;
 24872           /* Maybe add a space at the end of this line that is used to
 24873              display the cursor there under X.  Set the charpos of the
 24874              first glyph of blank lines not corresponding to any text
 24875              to -1.  */
 24876           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 24877             row->exact_window_width_line_p = true;
 24878           else if ((append_space_for_newline (it, true)
 24879                     && row->used[TEXT_AREA] == 1)
 24880                    || row->used[TEXT_AREA] == 0
 24881                    || (row_has_glyphs = row_text_area_empty (row)))
 24882             {
 24883               row->glyphs[TEXT_AREA]->charpos = -1;
 24884               /* Don't reset the displays_text_p flag if we are
 24885                  displaying line numbers or line-prefix.  */
 24886               if (!row_has_glyphs)
 24887                 row->displays_text_p = false;
 24888 
 24889               if (!NILP (BVAR (XBUFFER (it->w->contents), indicate_empty_lines))
 24890                   && (!MINI_WINDOW_P (it->w)))
 24891                 row->indicate_empty_line_p = true;
 24892             }
 24893 
 24894           it->continuation_lines_width = 0;
 24895           /* Reset those iterator values set from display property
 24896              values.  This is for the case when the display property
 24897              ends at ZV, and is not a replacing property, so pop_it is
 24898              not called.  */
 24899           it->font_height = Qnil;
 24900           it->voffset = 0;
 24901           row->ends_at_zv_p = true;
 24902           /* A row that displays right-to-left text must always have
 24903              its last face extended all the way to the end of line,
 24904              even if this row ends in ZV, because we still write to
 24905              the screen left to right.  We also need to extend the
 24906              last face if the default face is remapped to some
 24907              different face, otherwise the functions that clear
 24908              portions of the screen will clear with the default face's
 24909              background color.  */
 24910           if (row->reversed_p
 24911               || lookup_basic_face (it->w, it->f, DEFAULT_FACE_ID)
 24912               != DEFAULT_FACE_ID)
 24913             extend_face_to_end_of_line (it);
 24914           break;
 24915         }
 24916 
 24917       /* Now, get the metrics of what we want to display.  This also
 24918          generates glyphs in `row' (which is IT->glyph_row).  */
 24919       n_glyphs_before = row->used[TEXT_AREA];
 24920       x = it->current_x;
 24921 
 24922       /* Remember the line height so far in case the next element doesn't
 24923          fit on the line.  */
 24924       if (it->line_wrap != TRUNCATE)
 24925         {
 24926           ascent = it->max_ascent;
 24927           descent = it->max_descent;
 24928           phys_ascent = it->max_phys_ascent;
 24929           phys_descent = it->max_phys_descent;
 24930 
 24931           if (it->line_wrap == WORD_WRAP && it->area == TEXT_AREA)
 24932             {
 24933               bool next_may_wrap = may_wrap;
 24934               /* Can we wrap after this character?  */
 24935               if (char_can_wrap_after (it))
 24936                 next_may_wrap = true;
 24937               else
 24938                 next_may_wrap = false;
 24939               /* Can we wrap here? */
 24940               if (may_wrap && char_can_wrap_before (it))
 24941                 {
 24942                   SAVE_IT (wrap_it, *it, wrap_data);
 24943                   wrap_x = x;
 24944                   wrap_row_used = row->used[TEXT_AREA];
 24945                   wrap_row_ascent = row->ascent;
 24946                   wrap_row_height = row->height;
 24947                   wrap_row_phys_ascent = row->phys_ascent;
 24948                   wrap_row_phys_height = row->phys_height;
 24949                   wrap_row_extra_line_spacing = row->extra_line_spacing;
 24950                   wrap_row_min_pos = min_pos;
 24951                   wrap_row_min_bpos = min_bpos;
 24952                   wrap_row_max_pos = max_pos;
 24953                   wrap_row_max_bpos = max_bpos;
 24954                 }
 24955               /* Update may_wrap for the next iteration.  */
 24956               may_wrap = next_may_wrap;
 24957             }
 24958         }
 24959 
 24960       PRODUCE_GLYPHS (it);
 24961 
 24962       /* If this display element was in marginal areas, continue with
 24963          the next one.  */
 24964       if (it->area != TEXT_AREA)
 24965         {
 24966           row->ascent = max (row->ascent, it->max_ascent);
 24967           row->height = max (row->height, it->max_ascent + it->max_descent);
 24968           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 24969           row->phys_height = max (row->phys_height,
 24970                                   it->max_phys_ascent + it->max_phys_descent);
 24971           row->extra_line_spacing = max (row->extra_line_spacing,
 24972                                          it->max_extra_line_spacing);
 24973           set_iterator_to_next (it, true);
 24974           /* If we didn't handle the line/wrap prefix above, and the
 24975              call to set_iterator_to_next just switched to TEXT_AREA,
 24976              process the prefix now.  */
 24977           if (it->area == TEXT_AREA && pending_handle_line_prefix)
 24978             {
 24979               /* Line numbers should precede the line-prefix or wrap-prefix.  */
 24980               if (line_number_needed)
 24981                 maybe_produce_line_number (it);
 24982 
 24983               pending_handle_line_prefix = false;
 24984               handle_line_prefix (it);
 24985             }
 24986           continue;
 24987         }
 24988 
 24989       /* Does the display element fit on the line?  If we truncate
 24990          lines, we should draw past the right edge of the window.  If
 24991          we don't truncate, we want to stop so that we can display the
 24992          continuation glyph before the right margin.  If lines are
 24993          continued, there are two possible strategies for characters
 24994          resulting in more than 1 glyph (e.g. tabs): Display as many
 24995          glyphs as possible in this line and leave the rest for the
 24996          continuation line, or display the whole element in the next
 24997          line.  Original redisplay did the former, so we do it also.  */
 24998       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 24999       hpos_before = it->hpos;
 25000       x_before = x;
 25001 
 25002       if (/* Not a newline.  */
 25003           nglyphs > 0
 25004           /* Glyphs produced fit entirely in the line.  */
 25005           && it->current_x < it->last_visible_x)
 25006         {
 25007           it->hpos += nglyphs;
 25008           row->ascent = max (row->ascent, it->max_ascent);
 25009           row->height = max (row->height, it->max_ascent + it->max_descent);
 25010           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 25011           row->phys_height = max (row->phys_height,
 25012                                   it->max_phys_ascent + it->max_phys_descent);
 25013           row->extra_line_spacing = max (row->extra_line_spacing,
 25014                                          it->max_extra_line_spacing);
 25015           if (it->current_x - it->pixel_width < it->first_visible_x
 25016               /* When line numbers are displayed, row->x should not be
 25017                  offset, as the first glyph after the line number can
 25018                  never be partially visible.  */
 25019               && !line_number_needed
 25020               /* In R2L rows, we arrange in extend_face_to_end_of_line
 25021                  to add a right offset to the line, by a suitable
 25022                  change to the stretch glyph that is the leftmost
 25023                  glyph of the line.  */
 25024               && !row->reversed_p)
 25025             row->x = x - it->first_visible_x;
 25026           /* Record the maximum and minimum buffer positions seen so
 25027              far in glyphs that will be displayed by this row.  */
 25028           if (it->bidi_p)
 25029             RECORD_MAX_MIN_POS (it);
 25030         }
 25031       else
 25032         {
 25033           int i, new_x;
 25034           struct glyph *glyph;
 25035 
 25036           for (i = 0; i < nglyphs; ++i, x = new_x)
 25037             {
 25038               /* Identify the glyphs added by the last call to
 25039                  PRODUCE_GLYPHS.  In R2L rows, they are prepended to
 25040                  the previous glyphs.  */
 25041               if (!row->reversed_p)
 25042                 glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 25043               else
 25044                 glyph = row->glyphs[TEXT_AREA] + nglyphs - 1 - i;
 25045               new_x = x + glyph->pixel_width;
 25046 
 25047               if (/* Lines are continued.  */
 25048                   it->line_wrap != TRUNCATE
 25049                   && (/* Glyph doesn't fit on the line.  */
 25050                       new_x > it->last_visible_x
 25051                       /* Or it fits exactly on a window system frame.  */
 25052                       || (new_x == it->last_visible_x
 25053                           && FRAME_WINDOW_P (it->f)
 25054                           && (row->reversed_p
 25055                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25056                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w)))))
 25057                 {
 25058                   /* End of a continued line.  */
 25059 
 25060                   if (it->hpos == 0
 25061                       || (new_x == it->last_visible_x
 25062                           && FRAME_WINDOW_P (it->f)
 25063                           && (row->reversed_p
 25064                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25065                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w))))
 25066                     {
 25067                       /* Current glyph is the only one on the line or
 25068                          fits exactly on the line.  We must continue
 25069                          the line because we can't draw the cursor
 25070                          after the glyph.  */
 25071                       row->continued_p = true;
 25072                       it->current_x = new_x;
 25073                       it->continuation_lines_width += new_x;
 25074                       ++it->hpos;
 25075                       if (i == nglyphs - 1)
 25076                         {
 25077                           /* If line-wrap is on, check if a previous
 25078                              wrap point was found.  */
 25079                           if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it)
 25080                               && wrap_row_used > 0 /* Found.  */
 25081                               /* Even if there is a previous wrap
 25082                                  point, continue the line here as
 25083                                  usual, if (i) the previous character
 25084                                  allows wrapping after it, AND (ii)
 25085                                  the current character allows wrapping
 25086                                  before it.  Because this is a valid
 25087                                  break point, we can just continue to
 25088                                  the next line at here, there is no
 25089                                  need to wrap early at the previous
 25090                                  wrap point.  */
 25091                               && (!may_wrap || !char_can_wrap_before (it)))
 25092                             goto back_to_wrap;
 25093 
 25094                           /* Record the maximum and minimum buffer
 25095                              positions seen so far in glyphs that will be
 25096                              displayed by this row.  */
 25097                           if (it->bidi_p)
 25098                             RECORD_MAX_MIN_POS (it);
 25099                           set_iterator_to_next (it, true);
 25100                           if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25101                             {
 25102                               if (!get_next_display_element (it))
 25103                                 {
 25104                                   row->exact_window_width_line_p = true;
 25105                                   it->continuation_lines_width = 0;
 25106                                   it->font_height = Qnil;
 25107                                   it->voffset = 0;
 25108                                   row->continued_p = false;
 25109                                   row->ends_at_zv_p = true;
 25110                                 }
 25111                               else if (ITERATOR_AT_END_OF_LINE_P (it))
 25112                                 {
 25113                                   row->continued_p = false;
 25114                                   row->exact_window_width_line_p = true;
 25115                                 }
 25116                               /* If line-wrap is on, check if a
 25117                                  previous wrap point was found.  */
 25118                               else if (wrap_row_used > 0
 25119                                        /* Even if there is a previous
 25120                                           wrap point, continue the
 25121                                           line here as usual, if (i)
 25122                                           the previous character was a
 25123                                           space or tab AND (ii) the
 25124                                           current character is not,
 25125                                           AND (iii) the current
 25126                                           character allows wrapping
 25127                                           before it.  */
 25128                                        && (!may_wrap || !char_can_wrap_before (it)))
 25129                                 goto back_to_wrap;
 25130 
 25131                             }
 25132                         }
 25133                       else if (it->bidi_p)
 25134                         RECORD_MAX_MIN_POS (it);
 25135                       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 25136                           || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0)
 25137                         extend_face_to_end_of_line (it);
 25138                     }
 25139                   else if (CHAR_GLYPH_PADDING_P (*glyph)
 25140                            && !FRAME_WINDOW_P (it->f))
 25141                     {
 25142                       /* A padding glyph that doesn't fit on this line.
 25143                          This means the whole character doesn't fit
 25144                          on the line.  */
 25145                       if (row->reversed_p)
 25146                         unproduce_glyphs (it, row->used[TEXT_AREA]
 25147                                                - n_glyphs_before);
 25148                       row->used[TEXT_AREA] = n_glyphs_before;
 25149 
 25150                       /* Fill the rest of the row with continuation
 25151                          glyphs like in 20.x.  */
 25152                       while (row->glyphs[TEXT_AREA] + row->used[TEXT_AREA]
 25153                              < row->glyphs[1 + TEXT_AREA])
 25154                         produce_special_glyphs (it, IT_CONTINUATION);
 25155 
 25156                       row->continued_p = true;
 25157                       it->current_x = x_before;
 25158                       it->continuation_lines_width += x_before;
 25159 
 25160                       /* Restore the height to what it was before the
 25161                          element not fitting on the line.  */
 25162                       it->max_ascent = ascent;
 25163                       it->max_descent = descent;
 25164                       it->max_phys_ascent = phys_ascent;
 25165                       it->max_phys_descent = phys_descent;
 25166                       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 25167                           || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0)
 25168                         extend_face_to_end_of_line (it);
 25169                     }
 25170                   else if (wrap_row_used > 0)
 25171                     {
 25172                     back_to_wrap:
 25173                       if (row->reversed_p)
 25174                         unproduce_glyphs (it,
 25175                                           row->used[TEXT_AREA] - wrap_row_used);
 25176                       RESTORE_IT (it, &wrap_it, wrap_data);
 25177                       it->continuation_lines_width += wrap_x;
 25178                       row->used[TEXT_AREA] = wrap_row_used;
 25179                       row->ascent = wrap_row_ascent;
 25180                       row->height = wrap_row_height;
 25181                       row->phys_ascent = wrap_row_phys_ascent;
 25182                       row->phys_height = wrap_row_phys_height;
 25183                       row->extra_line_spacing = wrap_row_extra_line_spacing;
 25184                       min_pos = wrap_row_min_pos;
 25185                       min_bpos = wrap_row_min_bpos;
 25186                       max_pos = wrap_row_max_pos;
 25187                       max_bpos = wrap_row_max_bpos;
 25188                       row->continued_p = true;
 25189                       row->ends_at_zv_p = false;
 25190                       row->exact_window_width_line_p = false;
 25191 
 25192                       /* Make sure that a non-default face is extended
 25193                          up to the right margin of the window.  */
 25194                       extend_face_to_end_of_line (it);
 25195                     }
 25196                   else if ((it->what == IT_CHARACTER
 25197                             || it->what == IT_STRETCH
 25198                             || it->what == IT_COMPOSITION)
 25199                            && it->c == '\t' && FRAME_WINDOW_P (it->f))
 25200                     {
 25201                       /* A TAB that extends past the right edge of the
 25202                          window.  This produces a single glyph on
 25203                          window system frames.  We leave the glyph in
 25204                          this row and let it fill the row, but don't
 25205                          consume the TAB.  */
 25206                       if ((row->reversed_p
 25207                            ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25208                            : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0)
 25209                         produce_special_glyphs (it, IT_CONTINUATION);
 25210                       it->continuation_lines_width += it->last_visible_x;
 25211                       row->ends_in_middle_of_char_p = true;
 25212                       row->continued_p = true;
 25213                       glyph->pixel_width = it->last_visible_x - x;
 25214                       it->starts_in_middle_of_char_p = true;
 25215                       if (WINDOW_LEFT_MARGIN_WIDTH (it->w) > 0
 25216                           || WINDOW_RIGHT_MARGIN_WIDTH (it->w) > 0)
 25217                         extend_face_to_end_of_line (it);
 25218                     }
 25219                   else
 25220                     {
 25221                       /* Something other than a TAB that draws past
 25222                          the right edge of the window.  Restore
 25223                          positions to values before the element.  */
 25224                       if (row->reversed_p)
 25225                         unproduce_glyphs (it, row->used[TEXT_AREA]
 25226                                                - (n_glyphs_before + i));
 25227                       row->used[TEXT_AREA] = n_glyphs_before + i;
 25228 
 25229                       /* Display continuation glyphs.  */
 25230                       it->current_x = x_before;
 25231                       it->continuation_lines_width += x;
 25232                       if (!FRAME_WINDOW_P (it->f)
 25233                           || (row->reversed_p
 25234                               ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25235                               : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0)
 25236                         produce_special_glyphs (it, IT_CONTINUATION);
 25237                       row->continued_p = true;
 25238 
 25239                       extend_face_to_end_of_line (it);
 25240 
 25241                       if (nglyphs > 1 && i > 0)
 25242                         {
 25243                           row->ends_in_middle_of_char_p = true;
 25244                           it->starts_in_middle_of_char_p = true;
 25245                         }
 25246 
 25247                       /* Restore the height to what it was before the
 25248                          element not fitting on the line.  */
 25249                       it->max_ascent = ascent;
 25250                       it->max_descent = descent;
 25251                       it->max_phys_ascent = phys_ascent;
 25252                       it->max_phys_descent = phys_descent;
 25253                     }
 25254 
 25255                   break;
 25256                 }
 25257               else if (new_x > it->first_visible_x)
 25258                 {
 25259                   /* Increment number of glyphs actually displayed.  */
 25260                   ++it->hpos;
 25261 
 25262                   /* Record the maximum and minimum buffer positions
 25263                      seen so far in glyphs that will be displayed by
 25264                      this row.  */
 25265                   if (it->bidi_p)
 25266                     RECORD_MAX_MIN_POS (it);
 25267 
 25268                   if (x < it->first_visible_x && !row->reversed_p
 25269                       && !line_number_needed)
 25270                     /* Glyph is partially visible, i.e. row starts at
 25271                        negative X position.  Don't do that in R2L
 25272                        rows, where we arrange to add a right offset to
 25273                        the line in extend_face_to_end_of_line, by a
 25274                        suitable change to the stretch glyph that is
 25275                        the leftmost glyph of the line.  */
 25276                     row->x = x - it->first_visible_x;
 25277                   /* When the last glyph of an R2L row only fits
 25278                      partially on the line, we need to set row->x to a
 25279                      negative offset, so that the leftmost glyph is
 25280                      the one that is partially visible.  But if we are
 25281                      going to produce the truncation glyph, this will
 25282                      be taken care of in produce_special_glyphs.  */
 25283                   if (row->reversed_p
 25284                       && new_x > it->last_visible_x
 25285                       && !line_number_needed
 25286                       && !(it->line_wrap == TRUNCATE
 25287                            && WINDOW_LEFT_FRINGE_WIDTH (it->w) == 0))
 25288                     {
 25289                       eassert (FRAME_WINDOW_P (it->f));
 25290                       row->x = it->last_visible_x - new_x;
 25291                     }
 25292                 }
 25293               else
 25294                 {
 25295                   /* Glyph is completely off the left margin of the
 25296                      window.  This should not happen because of the
 25297                      move_it_in_display_line at the start of this
 25298                      function, unless the text display area of the
 25299                      window is empty.  */
 25300                   eassert (it->first_visible_x <= it->last_visible_x);
 25301                 }
 25302             }
 25303           /* Even if this display element produced no glyphs at all,
 25304              we want to record its position.  */
 25305           if (it->bidi_p && nglyphs == 0)
 25306             RECORD_MAX_MIN_POS (it);
 25307 
 25308           row->ascent = max (row->ascent, it->max_ascent);
 25309           row->height = max (row->height, it->max_ascent + it->max_descent);
 25310           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 25311           row->phys_height = max (row->phys_height,
 25312                                   it->max_phys_ascent + it->max_phys_descent);
 25313           row->extra_line_spacing = max (row->extra_line_spacing,
 25314                                          it->max_extra_line_spacing);
 25315 
 25316           /* End of this display line if row is continued.  */
 25317           if (row->continued_p || row->ends_at_zv_p)
 25318             break;
 25319         }
 25320 
 25321     at_end_of_line:
 25322       /* Is this a line end?  If yes, we're also done, after making
 25323          sure that a non-default face is extended up to the right
 25324          margin of the window.  */
 25325       if (ITERATOR_AT_END_OF_LINE_P (it))
 25326         {
 25327           int used_before = row->used[TEXT_AREA];
 25328 
 25329           row->ends_in_newline_from_string_p = STRINGP (it->object);
 25330 
 25331           /* Add a space at the end of the line that is used to
 25332              display the cursor there.  */
 25333           if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25334             append_space_for_newline (it, false);
 25335 
 25336           /* Extend the face to the end of the line.  */
 25337           extend_face_to_end_of_line (it);
 25338 
 25339           /* Make sure we have the position.  */
 25340           if (used_before == 0)
 25341             row->glyphs[TEXT_AREA]->charpos = CHARPOS (it->position);
 25342 
 25343           /* Record the position of the newline, for use in
 25344              find_row_edges.  */
 25345           it->eol_pos = it->current.pos;
 25346 
 25347           /* Consume the line end.  This skips over invisible lines.  */
 25348           set_iterator_to_next (it, true);
 25349           it->continuation_lines_width = 0;
 25350           break;
 25351         }
 25352 
 25353       /* Detect overly-wide wrap-prefixes made of (space ...) display
 25354          properties.  When such a wrap prefix reaches past the right
 25355          margin of the window, we need to avoid the call to
 25356          set_iterator_to_next below, so that it->line_wrap is left at
 25357          its TRUNCATE value wisely set by handle_line_prefix.
 25358          Otherwise, set_iterator_to_next will pop the iterator stack,
 25359          restore it->line_wrap, and redisplay might infloop.  */
 25360       bool overwide_wrap_prefix =
 25361         CONSP (it->object) && EQ (XCAR (it->object), Qspace)
 25362         && it->sp > 0 && it->method == GET_FROM_STRETCH
 25363         && it->current_x >= it->last_visible_x
 25364         && it->continuation_lines_width > 0
 25365         && it->line_wrap == TRUNCATE && it->stack[0].line_wrap != TRUNCATE;
 25366 
 25367       /* Proceed with next display element.  Note that this skips
 25368          over lines invisible because of selective display.  */
 25369       if (!overwide_wrap_prefix)
 25370         set_iterator_to_next (it, true);
 25371 
 25372       /* If we truncate lines, we are done when the last displayed
 25373          glyphs reach past the right margin of the window.  */
 25374       if (it->line_wrap == TRUNCATE
 25375           && ((FRAME_WINDOW_P (it->f)
 25376                /* Images are preprocessed in produce_image_glyph such
 25377                   that they are cropped at the right edge of the
 25378                   window, so an image glyph will always end exactly at
 25379                   last_visible_x, even if there's no right fringe.  */
 25380                && ((row->reversed_p
 25381                     ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25382                     : WINDOW_RIGHT_FRINGE_WIDTH (it->w))
 25383                    || it->what == IT_IMAGE))
 25384               ? (it->current_x >= it->last_visible_x)
 25385               : (it->current_x > it->last_visible_x)))
 25386         {
 25387           /* Maybe add truncation glyphs.  */
 25388           if (!FRAME_WINDOW_P (it->f)
 25389               || (row->reversed_p
 25390                   ? WINDOW_LEFT_FRINGE_WIDTH (it->w)
 25391                   : WINDOW_RIGHT_FRINGE_WIDTH (it->w)) == 0)
 25392             {
 25393               int i, n;
 25394 
 25395               if (!row->reversed_p)
 25396                 {
 25397                   for (i = row->used[TEXT_AREA] - 1; i > 0; --i)
 25398                     if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
 25399                       break;
 25400                 }
 25401               else
 25402                 {
 25403                   for (i = 0; i < row->used[TEXT_AREA]; i++)
 25404                     if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][i]))
 25405                       break;
 25406                   /* Remove any padding glyphs at the front of ROW, to
 25407                      make room for the truncation glyphs we will be
 25408                      adding below.  The loop below always inserts at
 25409                      least one truncation glyph, so also remove the
 25410                      last glyph added to ROW.  */
 25411                   unproduce_glyphs (it, i + 1);
 25412                   /* Adjust i for the loop below.  */
 25413                   i = row->used[TEXT_AREA] - (i + 1);
 25414                 }
 25415 
 25416               /* produce_special_glyphs overwrites the last glyph, so
 25417                  we don't want that if we want to keep that last
 25418                  glyph, which means it's an image.  */
 25419               if (it->current_x > it->last_visible_x)
 25420                 {
 25421                   it->current_x = x_before;
 25422                   if (!FRAME_WINDOW_P (it->f))
 25423                     {
 25424                       for (n = row->used[TEXT_AREA]; i < n; ++i)
 25425                         {
 25426                           row->used[TEXT_AREA] = i;
 25427                           produce_special_glyphs (it, IT_TRUNCATION);
 25428                         }
 25429                     }
 25430                   else
 25431                     {
 25432                       row->used[TEXT_AREA] = i;
 25433                       produce_special_glyphs (it, IT_TRUNCATION);
 25434                     }
 25435                   it->hpos = hpos_before;
 25436                 }
 25437             }
 25438           else if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
 25439             {
 25440               /* Don't truncate if we can overflow newline into fringe.  */
 25441               if (!get_next_display_element (it))
 25442                 {
 25443                   it->continuation_lines_width = 0;
 25444                   it->font_height = Qnil;
 25445                   it->voffset = 0;
 25446                   row->ends_at_zv_p = true;
 25447                   row->exact_window_width_line_p = true;
 25448                   break;
 25449                 }
 25450               if (ITERATOR_AT_END_OF_LINE_P (it))
 25451                 {
 25452                   row->exact_window_width_line_p = true;
 25453                   goto at_end_of_line;
 25454                 }
 25455               it->current_x = x_before;
 25456               it->hpos = hpos_before;
 25457             }
 25458 
 25459           row->truncated_on_right_p = true;
 25460           it->continuation_lines_width = 0;
 25461           reseat_at_next_visible_line_start (it, false);
 25462           /* We insist below that IT's position be at ZV because in
 25463              bidi-reordered lines the character at visible line start
 25464              might not be the character that follows the newline in
 25465              the logical order.  */
 25466           if (IT_BYTEPOS (*it) > BEG_BYTE)
 25467             row->ends_at_zv_p =
 25468               IT_BYTEPOS (*it) >= ZV_BYTE
 25469               && (ZV_BYTE <= 1 || FETCH_BYTE (ZV_BYTE - 1) != '\n');
 25470           else
 25471             row->ends_at_zv_p = false;
 25472           break;
 25473         }
 25474     }
 25475 
 25476   if (wrap_data)
 25477     bidi_unshelve_cache (wrap_data, true);
 25478 
 25479   /* If line is not empty and hscrolled, maybe insert truncation glyphs
 25480      at the left window margin.  */
 25481   if (it->first_visible_x
 25482       && IT_CHARPOS (*it) != CHARPOS (row->start.pos))
 25483     {
 25484       if (!FRAME_WINDOW_P (it->f)
 25485           || (((row->reversed_p
 25486                 ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
 25487                 : WINDOW_LEFT_FRINGE_WIDTH (it->w)) == 0)
 25488               /* Don't let insert_left_trunc_glyphs overwrite the
 25489                  first glyph of the row if it is an image.  */
 25490               && row->glyphs[TEXT_AREA]->type != IMAGE_GLYPH))
 25491         insert_left_trunc_glyphs (it);
 25492       row->truncated_on_left_p = true;
 25493     }
 25494 
 25495   /* Remember the position at which this line ends.
 25496 
 25497      BIDI Note: any code that needs MATRIX_ROW_START/END_CHARPOS
 25498      cannot be before the call to find_row_edges below, since that is
 25499      where these positions are determined. */
 25500   row->end = it->current;
 25501   if (!it->bidi_p)
 25502     {
 25503       row->minpos = row->start.pos;
 25504       row->maxpos = row->end.pos;
 25505     }
 25506   else
 25507     {
 25508       /* ROW->minpos and ROW->maxpos must be the smallest and
 25509          `1 + the largest' buffer positions in ROW.  But if ROW was
 25510          bidi-reordered, these two positions can be anywhere in the
 25511          row, so we must determine them now.  */
 25512       find_row_edges (it, row, min_pos, min_bpos, max_pos, max_bpos);
 25513     }
 25514 
 25515   /* If the start of this line is the overlay arrow-position, then
 25516      mark this glyph row as the one containing the overlay arrow.
 25517      This is clearly a mess with variable size fonts.  It would be
 25518      better to let it be displayed like cursors under X.  */
 25519   if ((MATRIX_ROW_DISPLAYS_TEXT_P (row) || !overlay_arrow_seen)
 25520       && (overlay_arrow_string = overlay_arrow_at_row (it, row),
 25521           !NILP (overlay_arrow_string)))
 25522     {
 25523       /* Overlay arrow in window redisplay is a fringe bitmap.  */
 25524       if (STRINGP (overlay_arrow_string))
 25525         {
 25526           struct glyph_row *arrow_row
 25527             = get_overlay_arrow_glyph_row (it->w, overlay_arrow_string);
 25528           struct glyph *glyph = arrow_row->glyphs[TEXT_AREA];
 25529           struct glyph *arrow_end = glyph + arrow_row->used[TEXT_AREA];
 25530           struct glyph *p = row->glyphs[TEXT_AREA];
 25531           struct glyph *p2, *end;
 25532 
 25533           /* Copy the arrow glyphs.  */
 25534           while (glyph < arrow_end)
 25535             *p++ = *glyph++;
 25536 
 25537           /* Throw away padding glyphs.  */
 25538           p2 = p;
 25539           end = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA];
 25540           while (p2 < end && CHAR_GLYPH_PADDING_P (*p2))
 25541             ++p2;
 25542           if (p2 > p)
 25543             {
 25544               while (p2 < end)
 25545                 *p++ = *p2++;
 25546               row->used[TEXT_AREA] = p2 - row->glyphs[TEXT_AREA];
 25547             }
 25548         }
 25549       else
 25550         {
 25551           eassert (FIXNUMP (overlay_arrow_string));
 25552           row->overlay_arrow_bitmap = XFIXNUM (overlay_arrow_string);
 25553         }
 25554       overlay_arrow_seen = true;
 25555     }
 25556 
 25557   /* Highlight trailing whitespace.  */
 25558   if (!NILP (Vshow_trailing_whitespace))
 25559     highlight_trailing_whitespace (it);
 25560 
 25561   /* Compute pixel dimensions of this line.  */
 25562   compute_line_metrics (it);
 25563 
 25564   /* Implementation note: No changes in the glyphs of ROW or in their
 25565      faces can be done past this point, because compute_line_metrics
 25566      computes ROW's hash value and stores it within the glyph_row
 25567      structure.  */
 25568 
 25569   /* Record whether this row ends inside an ellipsis.  */
 25570   row->ends_in_ellipsis_p
 25571     = (it->method == GET_FROM_DISPLAY_VECTOR
 25572        && it->ellipsis_p);
 25573 
 25574   /* Save fringe bitmaps in this row.  */
 25575   row->left_user_fringe_bitmap = it->left_user_fringe_bitmap;
 25576   row->left_user_fringe_face_id = it->left_user_fringe_face_id;
 25577   row->right_user_fringe_bitmap = it->right_user_fringe_bitmap;
 25578   row->right_user_fringe_face_id = it->right_user_fringe_face_id;
 25579 
 25580   it->left_user_fringe_bitmap = 0;
 25581   it->left_user_fringe_face_id = 0;
 25582   it->right_user_fringe_bitmap = 0;
 25583   it->right_user_fringe_face_id = 0;
 25584 
 25585   /* When they turn off tooltip-mode on a GUI frame, we call 'message'
 25586      with message-truncate-lines bound to non-nil, which produces
 25587      truncation bitmaps on the fringe.  Force redrawing of the fringes
 25588      in that case, to make sure the fringe bitmaps are removed when a
 25589      shorter message is displayed.  */
 25590   if (MINI_WINDOW_P (it->w) && it->line_wrap == TRUNCATE
 25591       && FRAME_WINDOW_P (it->f) && !cursor_in_echo_area)
 25592     row->redraw_fringe_bitmaps_p = true;
 25593 
 25594   /* Maybe set the cursor.  */
 25595   cvpos = it->w->cursor.vpos;
 25596   if ((cvpos < 0
 25597        /* In bidi-reordered rows, keep checking for proper cursor
 25598           position even if one has been found already, because buffer
 25599           positions in such rows change non-linearly with ROW->VPOS,
 25600           when a line is continued.  One exception: when we are at ZV,
 25601           display cursor on the first suitable glyph row, since all
 25602           the empty rows after that also have their position set to ZV.  */
 25603        /* FIXME: Revisit this when glyph ``spilling'' in continuation
 25604           lines' rows is implemented for bidi-reordered rows.  */
 25605        || (it->bidi_p
 25606            && !MATRIX_ROW (it->w->desired_matrix, cvpos)->ends_at_zv_p))
 25607       && PT >= MATRIX_ROW_START_CHARPOS (row)
 25608       && PT <= MATRIX_ROW_END_CHARPOS (row)
 25609       && cursor_row_p (row))
 25610     set_cursor_from_row (it->w, row, it->w->desired_matrix, 0, 0, 0, 0);
 25611 
 25612   /* Prepare for the next line.  This line starts horizontally at (X
 25613      HPOS) = (0 0).  Vertical positions are incremented.  As a
 25614      convenience for the caller, IT->glyph_row is set to the next
 25615      row to be used.  */
 25616   it->current_x = it->hpos = 0;
 25617   it->current_y += row->height;
 25618   /* Restore the first and last visible X if we adjusted them for
 25619      current-line hscrolling.  */
 25620   if (hscroll_this_line)
 25621     {
 25622       it->first_visible_x = first_visible_x;
 25623       it->last_visible_x  = last_visible_x;
 25624     }
 25625   SET_TEXT_POS (it->eol_pos, 0, 0);
 25626   ++it->vpos;
 25627   ++it->glyph_row;
 25628   /* The next row should by default use the same value of the
 25629      reversed_p flag as this one.  set_iterator_to_next decides when
 25630      it's a new paragraph, and PRODUCE_GLYPHS recomputes the value of
 25631      the flag accordingly.  */
 25632   if (it->glyph_row < MATRIX_BOTTOM_TEXT_ROW (it->w->desired_matrix, it->w))
 25633     it->glyph_row->reversed_p = row->reversed_p;
 25634   it->start = row->end;
 25635   return MATRIX_ROW_DISPLAYS_TEXT_P (row);
 25636 
 25637 #undef RECORD_MAX_MIN_POS
 25638 }
 25639 
 25640 DEFUN ("current-bidi-paragraph-direction", Fcurrent_bidi_paragraph_direction,
 25641        Scurrent_bidi_paragraph_direction, 0, 1, 0,
 25642        doc: /* Return paragraph direction at point in BUFFER.
 25643 Value is either `left-to-right' or `right-to-left'.
 25644 If BUFFER is omitted or nil, it defaults to the current buffer.
 25645 
 25646 Paragraph direction determines how the text in the paragraph is displayed.
 25647 In left-to-right paragraphs, text begins at the left margin of the window
 25648 and the reading direction is generally left to right.  In right-to-left
 25649 paragraphs, text begins at the right margin and is read from right to left.
 25650 
 25651 See also `bidi-paragraph-direction'.  */)
 25652   (Lisp_Object buffer)
 25653 {
 25654   struct buffer *buf = current_buffer;
 25655   struct buffer *old = buf;
 25656 
 25657   if (! NILP (buffer))
 25658     {
 25659       CHECK_BUFFER (buffer);
 25660       buf = XBUFFER (buffer);
 25661     }
 25662 
 25663   if (NILP (BVAR (buf, bidi_display_reordering))
 25664       || NILP (BVAR (buf, enable_multibyte_characters))
 25665       /* When we are loading loadup.el, the character property tables
 25666          needed for bidi iteration are not yet available.  */
 25667       || redisplay__inhibit_bidi)
 25668     return Qleft_to_right;
 25669   else if (!NILP (BVAR (buf, bidi_paragraph_direction)))
 25670     return BVAR (buf, bidi_paragraph_direction);
 25671   else
 25672     {
 25673       /* Determine the direction from buffer text.  We could try to
 25674          use current_matrix if it is up to date, but this seems fast
 25675          enough as it is.  */
 25676       struct bidi_it itb;
 25677       ptrdiff_t pos = BUF_PT (buf);
 25678       ptrdiff_t bytepos = BUF_PT_BYTE (buf);
 25679       int c;
 25680       void *itb_data = bidi_shelve_cache ();
 25681 
 25682       set_buffer_temp (buf);
 25683       /* bidi_paragraph_init finds the base direction of the paragraph
 25684          by searching forward from paragraph start.  We need the base
 25685          direction of the current or _previous_ paragraph, so we need
 25686          to make sure we are within that paragraph.  To that end, find
 25687          the previous non-empty line.  */
 25688       if (pos >= ZV && pos > BEGV)
 25689         dec_both (&pos, &bytepos);
 25690       AUTO_STRING (trailing_white_space, "[\f\t ]*\n");
 25691       if (fast_looking_at (trailing_white_space,
 25692                            pos, bytepos, ZV, ZV_BYTE, Qnil) > 0)
 25693         {
 25694           while ((c = FETCH_BYTE (bytepos)) == '\n'
 25695                  || c == ' ' || c == '\t' || c == '\f')
 25696             {
 25697               if (bytepos <= BEGV_BYTE)
 25698                 break;
 25699               bytepos--;
 25700               pos--;
 25701             }
 25702           while (!CHAR_HEAD_P (FETCH_BYTE (bytepos)))
 25703             bytepos--;
 25704         }
 25705       bidi_init_it (pos, bytepos, FRAME_WINDOW_P (SELECTED_FRAME ()), &itb);
 25706       itb.paragraph_dir = NEUTRAL_DIR;
 25707       itb.string.s = NULL;
 25708       itb.string.lstring = Qnil;
 25709       itb.string.bufpos = 0;
 25710       itb.string.from_disp_str = false;
 25711       itb.string.unibyte = false;
 25712       /* We have no window to use here for ignoring window-specific
 25713          overlays.  Using NULL for window pointer will cause
 25714          compute_display_string_pos to use the current buffer.  */
 25715       itb.w = NULL;
 25716       bidi_paragraph_init (NEUTRAL_DIR, &itb, true);
 25717       bidi_unshelve_cache (itb_data, false);
 25718       set_buffer_temp (old);
 25719       switch (itb.paragraph_dir)
 25720         {
 25721         case L2R:
 25722           return Qleft_to_right;
 25723           break;
 25724         case R2L:
 25725           return Qright_to_left;
 25726           break;
 25727         default:
 25728           emacs_abort ();
 25729         }
 25730     }
 25731 }
 25732 
 25733 DEFUN ("bidi-find-overridden-directionality",
 25734        Fbidi_find_overridden_directionality,
 25735        Sbidi_find_overridden_directionality, 3, 4, 0,
 25736        doc: /* Return position between FROM and TO where directionality was overridden.
 25737 
 25738 This function returns the first character position in the specified
 25739 region of OBJECT where characters have their bidirectional
 25740 properties affected in a way that might make its text look confusingly
 25741 on display.  For example, characters whose `bidi-class' property is `L',
 25742 could be forced to display as `R' by a directional override, and
 25743 likewise characters whose `bidi-class' is `R' or `AL' that are
 25744 forced to display as `L'.
 25745 
 25746 If no such character is found, the function returns nil.
 25747 
 25748 OBJECT is a Lisp string or buffer to search for overridden
 25749 directionality, and defaults to the current buffer if nil.
 25750 OBJECT can also be a window, in which case the function will search
 25751 the buffer displayed in that window.  Passing the window instead of
 25752 a buffer is preferable when the buffer is displayed in some window,
 25753 because this function will then be able to correctly account for
 25754 window-specific overlays, which can affect the results.
 25755 
 25756 Optional argument BASE-DIR specifies the base paragraph directory
 25757 of the text.  It should be a symbol, either `left-to-right'
 25758 or `right-to-left', and defaults to `left-to-right'.
 25759 
 25760 Strong directional characters `L', `R', and `AL' can have their
 25761 intrinsic directionality overridden by directional override control
 25762 characters RLO (u+202E) and LRO (u+202D).  They can also have their
 25763 directionality affected by other formatting control characters: LRE
 25764 (u+202A), RLE (u+202B), LRI (u+2066), and RLI (u+2067).  See the
 25765 function `get-char-code-property' for a way to inquire about the
 25766 `bidi-class' property of a character.  Characters whose intrinsic
 25767 directionality is weak or neutral, such as numbers or punctuation
 25768 characters, can be forced to display in a very different place with
 25769 respect of its surrounding characters, so as to make the surrounding
 25770 text confuse the user regarding what the text says.
 25771 
 25772 Also see the `highlight-confusing-reorderings' function, which can be
 25773 useful in similar circumstances as this function.  */)
 25774   (Lisp_Object from, Lisp_Object to, Lisp_Object object, Lisp_Object base_dir)
 25775 {
 25776   struct buffer *buf = current_buffer;
 25777   struct buffer *old = buf;
 25778   struct window *w = NULL;
 25779   bool frame_window_p = FRAME_WINDOW_P (SELECTED_FRAME ());
 25780   struct bidi_it itb;
 25781   ptrdiff_t from_pos, to_pos, from_bpos;
 25782   void *itb_data;
 25783 
 25784   if (!NILP (object))
 25785     {
 25786       if (BUFFERP (object))
 25787         buf = XBUFFER (object);
 25788       else if (WINDOWP (object))
 25789         {
 25790           w = decode_live_window (object);
 25791           buf = XBUFFER (w->contents);
 25792           frame_window_p = FRAME_WINDOW_P (XFRAME (w->frame));
 25793         }
 25794       else
 25795         CHECK_STRING (object);
 25796     }
 25797 
 25798   if (STRINGP (object))
 25799     {
 25800       /* Characters in unibyte strings are always treated by bidi.c as
 25801          strong LTR.  */
 25802       if (!STRING_MULTIBYTE (object)
 25803           /* When we are loading loadup.el, the character property
 25804              tables needed for bidi iteration are not yet
 25805              available.  */
 25806           || redisplay__inhibit_bidi)
 25807         return Qnil;
 25808 
 25809       validate_subarray (object, from, to, SCHARS (object), &from_pos, &to_pos);
 25810       if (from_pos >= SCHARS (object))
 25811         return Qnil;
 25812 
 25813       /* Set up the bidi iterator.  */
 25814       itb_data = bidi_shelve_cache ();
 25815       itb.paragraph_dir = NEUTRAL_DIR;
 25816       itb.string.lstring = object;
 25817       itb.string.s = NULL;
 25818       itb.string.schars = SCHARS (object);
 25819       itb.string.bufpos = 0;
 25820       itb.string.from_disp_str = false;
 25821       itb.string.unibyte = false;
 25822       itb.w = w;
 25823       bidi_init_it (0, 0, frame_window_p, &itb);
 25824     }
 25825   else
 25826     {
 25827       /* Nothing this fancy can happen in unibyte buffers, or in a
 25828          buffer that disabled reordering, or if FROM is at EOB.  */
 25829       if (NILP (BVAR (buf, bidi_display_reordering))
 25830           || NILP (BVAR (buf, enable_multibyte_characters))
 25831           /* When we are loading loadup.el, the character property
 25832              tables needed for bidi iteration are not yet
 25833              available.  */
 25834           || redisplay__inhibit_bidi)
 25835         return Qnil;
 25836 
 25837       set_buffer_temp (buf);
 25838       validate_region (&from, &to);
 25839       from_pos = XFIXNUM (from);
 25840       to_pos = XFIXNUM (to);
 25841       if (from_pos >= ZV)
 25842         return Qnil;
 25843 
 25844       /* Set up the bidi iterator.  */
 25845       itb_data = bidi_shelve_cache ();
 25846       from_bpos = CHAR_TO_BYTE (from_pos);
 25847       if (from_pos == BEGV)
 25848         {
 25849           itb.charpos = BEGV;
 25850           itb.bytepos = BEGV_BYTE;
 25851         }
 25852       else if (FETCH_BYTE (from_bpos - 1) == '\n')
 25853         {
 25854           itb.charpos = from_pos;
 25855           itb.bytepos = from_bpos;
 25856         }
 25857       else
 25858         itb.charpos = find_newline_no_quit (from_pos, CHAR_TO_BYTE (from_pos),
 25859                                             -1, &itb.bytepos);
 25860       itb.paragraph_dir = NEUTRAL_DIR;
 25861       itb.string.s = NULL;
 25862       itb.string.lstring = Qnil;
 25863       itb.string.bufpos = 0;
 25864       itb.string.from_disp_str = false;
 25865       itb.string.unibyte = false;
 25866       itb.w = w;
 25867       bidi_init_it (itb.charpos, itb.bytepos, frame_window_p, &itb);
 25868     }
 25869 
 25870   ptrdiff_t found;
 25871   bidi_dir_t bdir = EQ (base_dir, Qright_to_left) ? R2L : L2R;
 25872   do {
 25873     bidi_paragraph_init (bdir, &itb, false);
 25874     while ((found = bidi_find_first_overridden (&itb)) < from_pos)
 25875       ;
 25876   } while (found == ZV && itb.ch == '\n' && itb.charpos < to_pos);
 25877 
 25878   bidi_unshelve_cache (itb_data, false);
 25879   set_buffer_temp (old);
 25880 
 25881   return (from_pos <= found && found < to_pos) ? make_fixnum (found) : Qnil;
 25882 }
 25883 
 25884 DEFUN ("move-point-visually", Fmove_point_visually,
 25885        Smove_point_visually, 1, 1, 0,
 25886        doc: /* Move point in the visual order in the specified DIRECTION.
 25887 DIRECTION can be 1, meaning move to the right, or -1, which moves to the
 25888 left.
 25889 
 25890 Value is the new character position of point.  */)
 25891   (Lisp_Object direction)
 25892 {
 25893   struct window *w = XWINDOW (selected_window);
 25894   struct buffer *b = XBUFFER (w->contents);
 25895   struct glyph_row *row;
 25896   int dir;
 25897   Lisp_Object paragraph_dir;
 25898 
 25899 #define ROW_GLYPH_NEWLINE_P(ROW,GLYPH)          \
 25900   (!(ROW)->continued_p                          \
 25901    && NILP ((GLYPH)->object)                    \
 25902    && (GLYPH)->type == CHAR_GLYPH               \
 25903    && (GLYPH)->u.ch == ' '                      \
 25904    && (GLYPH)->charpos >= 0                     \
 25905    && !(GLYPH)->avoid_cursor_p)
 25906 
 25907   CHECK_FIXNUM (direction);
 25908   dir = XFIXNUM (direction);
 25909   if (dir > 0)
 25910     dir = 1;
 25911   else
 25912     dir = -1;
 25913 
 25914   /* If current matrix is up-to-date, we can use the information
 25915      recorded in the glyphs, at least as long as the goal is on the
 25916      screen.  */
 25917   if (w->window_end_valid
 25918       && !windows_or_buffers_changed
 25919       && b
 25920       && !b->clip_changed
 25921       && !b->prevent_redisplay_optimizations_p
 25922       && !window_outdated (w)
 25923       /* We rely below on the cursor coordinates to be up to date, but
 25924          we cannot trust them if some command moved point since the
 25925          last complete redisplay.  */
 25926       && w->last_point == BUF_PT (b)
 25927       && w->cursor.vpos >= 0
 25928       && w->cursor.vpos < w->current_matrix->nrows
 25929       && (row = MATRIX_ROW (w->current_matrix, w->cursor.vpos))->enabled_p)
 25930     {
 25931       struct glyph *g = row->glyphs[TEXT_AREA];
 25932       struct glyph *e = dir > 0 ? g + row->used[TEXT_AREA] : g - 1;
 25933       struct glyph *gpt = g + w->cursor.hpos;
 25934 
 25935       for (g = gpt + dir; (dir > 0 ? g < e : g > e); g += dir)
 25936         {
 25937           if (BUFFERP (g->object) && g->charpos != PT)
 25938             {
 25939               SET_PT (g->charpos);
 25940               w->cursor.vpos = -1;
 25941               return make_fixnum (PT);
 25942             }
 25943           else if (!NILP (g->object) && !EQ (g->object, gpt->object))
 25944             {
 25945               ptrdiff_t new_pos;
 25946 
 25947               if (BUFFERP (gpt->object))
 25948                 {
 25949                   new_pos = PT;
 25950                   if ((gpt->resolved_level - row->reversed_p) % 2 == 0)
 25951                     new_pos += (row->reversed_p ? -dir : dir);
 25952                   else
 25953                     new_pos -= (row->reversed_p ? -dir : dir);
 25954                   new_pos = clip_to_bounds (BEGV, new_pos, ZV);
 25955                   /* If we didn't move, we've hit BEGV or ZV, so we
 25956                      need to signal a suitable error.  */
 25957                   if (new_pos == PT)
 25958                     break;
 25959                 }
 25960               else if (BUFFERP (g->object))
 25961                 new_pos = g->charpos;
 25962               else
 25963                 break;
 25964               SET_PT (new_pos);
 25965               w->cursor.vpos = -1;
 25966               return make_fixnum (PT);
 25967             }
 25968           else if (ROW_GLYPH_NEWLINE_P (row, g))
 25969             {
 25970               /* Glyphs inserted at the end of a non-empty line for
 25971                  positioning the cursor have zero charpos, so we must
 25972                  deduce the value of point by other means.  */
 25973               if (g->charpos > 0)
 25974                 SET_PT (g->charpos);
 25975               else if (row->ends_at_zv_p && PT != ZV)
 25976                 SET_PT (ZV);
 25977               else if (PT != MATRIX_ROW_END_CHARPOS (row) - 1)
 25978                 SET_PT (MATRIX_ROW_END_CHARPOS (row) - 1);
 25979               else
 25980                 break;
 25981               w->cursor.vpos = -1;
 25982               return make_fixnum (PT);
 25983             }
 25984         }
 25985       if (g == e || NILP (g->object))
 25986         {
 25987           if (row->truncated_on_left_p || row->truncated_on_right_p)
 25988             goto simulate_display;
 25989           if (!row->reversed_p)
 25990             row += dir;
 25991           else
 25992             row -= dir;
 25993           if (!(MATRIX_FIRST_TEXT_ROW (w->current_matrix) <= row
 25994                 && row < MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w)))
 25995             goto simulate_display;
 25996 
 25997           if (dir > 0)
 25998             {
 25999               if (row->reversed_p && !row->continued_p)
 26000                 {
 26001                   SET_PT (MATRIX_ROW_END_CHARPOS (row) - 1);
 26002                   w->cursor.vpos = -1;
 26003                   return make_fixnum (PT);
 26004                 }
 26005               g = row->glyphs[TEXT_AREA];
 26006               e = g + row->used[TEXT_AREA];
 26007               for ( ; g < e; g++)
 26008                 {
 26009                   if (BUFFERP (g->object)
 26010                       /* Empty lines have only one glyph, which stands
 26011                          for the newline, and whose charpos is the
 26012                          buffer position of the newline.  */
 26013                       || ROW_GLYPH_NEWLINE_P (row, g)
 26014                       /* When the buffer ends in a newline, the line at
 26015                          EOB also has one glyph, but its charpos is -1.  */
 26016                       || (row->ends_at_zv_p
 26017                           && !row->reversed_p
 26018                           && NILP (g->object)
 26019                           && g->type == CHAR_GLYPH
 26020                           && g->u.ch == ' '))
 26021                     {
 26022                       if (g->charpos > 0)
 26023                         SET_PT (g->charpos);
 26024                       else if (!row->reversed_p
 26025                                && row->ends_at_zv_p
 26026                                && PT != ZV)
 26027                         SET_PT (ZV);
 26028                       else
 26029                         continue;
 26030                       w->cursor.vpos = -1;
 26031                       return make_fixnum (PT);
 26032                     }
 26033                 }
 26034             }
 26035           else
 26036             {
 26037               if (!row->reversed_p && !row->continued_p)
 26038                 {
 26039                   SET_PT (MATRIX_ROW_END_CHARPOS (row) - 1);
 26040                   w->cursor.vpos = -1;
 26041                   return make_fixnum (PT);
 26042                 }
 26043               e = row->glyphs[TEXT_AREA];
 26044               g = e + row->used[TEXT_AREA] - 1;
 26045               for ( ; g >= e; g--)
 26046                 {
 26047                   if (BUFFERP (g->object)
 26048                       || (ROW_GLYPH_NEWLINE_P (row, g)
 26049                           && g->charpos > 0)
 26050                       /* Empty R2L lines on GUI frames have the buffer
 26051                          position of the newline stored in the stretch
 26052                          glyph.  */
 26053                       || g->type == STRETCH_GLYPH
 26054                       || (row->ends_at_zv_p
 26055                           && row->reversed_p
 26056                           && NILP (g->object)
 26057                           && g->type == CHAR_GLYPH
 26058                           && g->u.ch == ' '))
 26059                     {
 26060                       if (g->charpos > 0)
 26061                         SET_PT (g->charpos);
 26062                       else if (row->reversed_p
 26063                                && row->ends_at_zv_p
 26064                                && PT != ZV)
 26065                         SET_PT (ZV);
 26066                       else
 26067                         continue;
 26068                       w->cursor.vpos = -1;
 26069                       return make_fixnum (PT);
 26070                     }
 26071                 }
 26072             }
 26073         }
 26074     }
 26075 
 26076  simulate_display:
 26077 
 26078   /* If we wind up here, we failed to move by using the glyphs, so we
 26079      need to simulate display instead.  */
 26080 
 26081   if (b)
 26082     paragraph_dir = Fcurrent_bidi_paragraph_direction (w->contents);
 26083   else
 26084     paragraph_dir = Qleft_to_right;
 26085   if (EQ (paragraph_dir, Qright_to_left))
 26086     dir = -dir;
 26087   if (PT <= BEGV && dir < 0)
 26088     xsignal0 (Qbeginning_of_buffer);
 26089   else if (PT >= ZV && dir > 0)
 26090     xsignal0 (Qend_of_buffer);
 26091   else
 26092     {
 26093       struct text_pos pt;
 26094       struct it it;
 26095       int pt_x, target_x, pixel_width, pt_vpos;
 26096       bool at_eol_p;
 26097       bool overshoot_expected = false;
 26098       bool target_is_eol_p = false;
 26099       void *itdata = bidi_shelve_cache ();
 26100 
 26101       /* Setup the arena.  */
 26102       SET_TEXT_POS (pt, PT, PT_BYTE);
 26103       start_display (&it, w, pt);
 26104       /* When lines are truncated, we could be called with point
 26105          outside of the windows edges, in which case move_it_*
 26106          functions either prematurely stop at window's edge or jump to
 26107          the next screen line, whereas we rely below on our ability to
 26108          reach point, in order to start from its X coordinate.  So we
 26109          need to disregard the window's horizontal extent in that case.  */
 26110       if (it.line_wrap == TRUNCATE)
 26111         it.last_visible_x = DISP_INFINITY;
 26112 
 26113       if (it.cmp_it.id < 0
 26114           && it.method == GET_FROM_STRING
 26115           && it.area == TEXT_AREA
 26116           && it.string_from_display_prop_p
 26117           && (it.sp > 0 && it.stack[it.sp - 1].method == GET_FROM_BUFFER))
 26118         overshoot_expected = true;
 26119 
 26120       /* Find the X coordinate of point.  We start from the beginning
 26121          of this or previous line to make sure we are before point in
 26122          the logical order (since the move_it_* functions can only
 26123          move forward).  */
 26124     reseat:
 26125       reseat_at_previous_visible_line_start (&it);
 26126       it.current_x = it.hpos = it.current_y = it.vpos = 0;
 26127       if (IT_CHARPOS (it) != PT)
 26128         {
 26129           move_it_to (&it, overshoot_expected ? PT - 1 : PT,
 26130                       -1, -1, -1, MOVE_TO_POS);
 26131           /* If we missed point because the character there is
 26132              displayed out of a display vector that has more than one
 26133              glyph, retry expecting overshoot.  */
 26134           if (it.method == GET_FROM_DISPLAY_VECTOR
 26135               && it.current.dpvec_index > 0
 26136               && !overshoot_expected)
 26137             {
 26138               overshoot_expected = true;
 26139               goto reseat;
 26140             }
 26141           else if (IT_CHARPOS (it) != PT && !overshoot_expected)
 26142             move_it_in_display_line (&it, PT, -1, MOVE_TO_POS);
 26143         }
 26144       pt_x = it.current_x;
 26145       pt_vpos = it.vpos;
 26146       if (dir > 0 || overshoot_expected)
 26147         {
 26148           struct glyph_row *row = it.glyph_row;
 26149 
 26150           /* When point is at beginning of line, we don't have
 26151              information about the glyph there loaded into struct
 26152              it.  Calling get_next_display_element fixes that.  */
 26153           if (pt_x == 0)
 26154             get_next_display_element (&it);
 26155           at_eol_p = ITERATOR_AT_END_OF_LINE_P (&it);
 26156           it.glyph_row = NULL;
 26157           PRODUCE_GLYPHS (&it); /* compute it.pixel_width */
 26158           it.glyph_row = row;
 26159           /* PRODUCE_GLYPHS advances it.current_x, so we must restore
 26160              it, lest it will become out of sync with it's buffer
 26161              position.  */
 26162           it.current_x = pt_x;
 26163         }
 26164       else
 26165         at_eol_p = ITERATOR_AT_END_OF_LINE_P (&it);
 26166       pixel_width = it.pixel_width;
 26167       if (overshoot_expected && at_eol_p)
 26168         pixel_width = 0;
 26169       else if (pixel_width <= 0)
 26170         pixel_width = 1;
 26171 
 26172       /* If there's a display string (or something similar) at point,
 26173          we are actually at the glyph to the left of point, so we need
 26174          to correct the X coordinate.  */
 26175       if (overshoot_expected)
 26176         {
 26177           if (it.bidi_p)
 26178             pt_x += pixel_width * it.bidi_it.scan_dir;
 26179           else
 26180             pt_x += pixel_width;
 26181         }
 26182 
 26183       /* Compute target X coordinate, either to the left or to the
 26184          right of point.  On TTY frames, all characters have the same
 26185          pixel width of 1, so we can use that.  On GUI frames we don't
 26186          have an easy way of getting at the pixel width of the
 26187          character to the left of point, so we use a different method
 26188          of getting to that place.  */
 26189       if (dir > 0)
 26190         target_x = pt_x + pixel_width;
 26191       else
 26192         target_x = pt_x - (!FRAME_WINDOW_P (it.f)) * pixel_width;
 26193 
 26194       /* Target X coordinate could be one line above or below the line
 26195          of point, in which case we need to adjust the target X
 26196          coordinate.  Also, if moving to the left, we need to begin at
 26197          the left edge of the point's screen line.  */
 26198       if (dir < 0)
 26199         {
 26200           if (pt_x > 0)
 26201             {
 26202               start_display (&it, w, pt);
 26203               if (it.line_wrap == TRUNCATE)
 26204                 it.last_visible_x = DISP_INFINITY;
 26205               reseat_at_previous_visible_line_start (&it);
 26206               it.current_x = it.current_y = it.hpos = 0;
 26207               if (pt_vpos != 0)
 26208                 move_it_by_lines (&it, pt_vpos);
 26209             }
 26210           else
 26211             {
 26212               move_it_by_lines (&it, -1);
 26213               target_x = it.last_visible_x - !FRAME_WINDOW_P (it.f);
 26214               target_is_eol_p = true;
 26215               /* Under word-wrap, we don't know the x coordinate of
 26216                  the last character displayed on the previous line,
 26217                  which immediately precedes the wrap point.  To find
 26218                  out its x coordinate, we try moving to the right
 26219                  margin of the window, which will stop at the wrap
 26220                  point, and then reset target_x to point at the
 26221                  character that precedes the wrap point.  This is not
 26222                  needed on GUI frames, because (see below) there we
 26223                  move from the left margin one grapheme cluster at a
 26224                  time, and stop when we hit the wrap point.  */
 26225               if (!FRAME_WINDOW_P (it.f) && it.line_wrap == WORD_WRAP)
 26226                 {
 26227                   void *it_data = NULL;
 26228                   struct it it2;
 26229 
 26230                   SAVE_IT (it2, it, it_data);
 26231                   move_it_in_display_line_to (&it, ZV, target_x,
 26232                                               MOVE_TO_POS | MOVE_TO_X);
 26233                   /* If we arrived at target_x, that _is_ the last
 26234                      character on the previous line.  */
 26235                   if (it.current_x != target_x)
 26236                     target_x = it.current_x - 1;
 26237                   RESTORE_IT (&it, &it2, it_data);
 26238                 }
 26239             }
 26240         }
 26241       else
 26242         {
 26243           if (at_eol_p
 26244               || (target_x >= it.last_visible_x
 26245                   && it.line_wrap != TRUNCATE))
 26246             {
 26247               if (pt_x > 0)
 26248                 move_it_by_lines (&it, 0);
 26249               move_it_by_lines (&it, 1);
 26250               target_x = 0;
 26251             }
 26252         }
 26253 
 26254       /* Move to the target X coordinate.  */
 26255       /* On GUI frames, as we don't know the X coordinate of the
 26256          character to the left of point, moving point to the left
 26257          requires walking, one grapheme cluster at a time, until we
 26258          find ourself at a place immediately to the left of the
 26259          character at point.  */
 26260       if (FRAME_WINDOW_P (it.f) && dir < 0)
 26261         {
 26262           struct text_pos new_pos;
 26263           enum move_it_result rc = MOVE_X_REACHED;
 26264 
 26265           if (it.current_x == 0)
 26266             get_next_display_element (&it);
 26267           if (it.what == IT_COMPOSITION)
 26268             {
 26269               new_pos.charpos = it.cmp_it.charpos;
 26270               new_pos.bytepos = -1;
 26271             }
 26272           else
 26273             new_pos = it.current.pos;
 26274 
 26275           while (it.current_x + it.pixel_width <= target_x
 26276                  && (rc == MOVE_X_REACHED
 26277                      /* Under word-wrap, move_it_in_display_line_to
 26278                         stops at correct coordinates, but sometimes
 26279                         returns MOVE_POS_MATCH_OR_ZV.  */
 26280                      || (it.line_wrap == WORD_WRAP
 26281                          && rc == MOVE_POS_MATCH_OR_ZV)))
 26282             {
 26283               int new_x = it.current_x + it.pixel_width;
 26284 
 26285               /* For composed characters, we want the position of the
 26286                  first character in the grapheme cluster (usually, the
 26287                  composition's base character), whereas it.current
 26288                  might give us the position of the _last_ one, e.g. if
 26289                  the composition is rendered in reverse due to bidi
 26290                  reordering.  */
 26291               if (it.what == IT_COMPOSITION)
 26292                 {
 26293                   new_pos.charpos = it.cmp_it.charpos;
 26294                   new_pos.bytepos = -1;
 26295                 }
 26296               else
 26297                 new_pos = it.current.pos;
 26298               if (new_x == it.current_x)
 26299                 new_x++;
 26300               rc = move_it_in_display_line_to (&it, ZV, new_x,
 26301                                                MOVE_TO_POS | MOVE_TO_X);
 26302               if (ITERATOR_AT_END_OF_LINE_P (&it) && !target_is_eol_p)
 26303                 break;
 26304             }
 26305           /* The previous position we saw in the loop is the one we
 26306              want.  */
 26307           if (new_pos.bytepos == -1)
 26308             new_pos.bytepos = CHAR_TO_BYTE (new_pos.charpos);
 26309           it.current.pos = new_pos;
 26310         }
 26311       else if (it.current_x != target_x)
 26312         move_it_in_display_line_to (&it, ZV, target_x, MOVE_TO_POS | MOVE_TO_X);
 26313 
 26314       /* If we ended up in a display string that covers point, move to
 26315          buffer position to the right in the visual order.  */
 26316       if (dir > 0)
 26317         {
 26318           while (IT_CHARPOS (it) == PT)
 26319             {
 26320               set_iterator_to_next (&it, false);
 26321               if (!get_next_display_element (&it))
 26322                 break;
 26323             }
 26324         }
 26325 
 26326       /* Move point to that position.  */
 26327       SET_PT_BOTH (IT_CHARPOS (it), IT_BYTEPOS (it));
 26328       bidi_unshelve_cache (itdata, false);
 26329     }
 26330 
 26331   return make_fixnum (PT);
 26332 
 26333 #undef ROW_GLYPH_NEWLINE_P
 26334 }
 26335 
 26336 DEFUN ("bidi-resolved-levels", Fbidi_resolved_levels,
 26337        Sbidi_resolved_levels, 0, 1, 0,
 26338        doc: /* Return the resolved bidirectional levels of characters at VPOS.
 26339 
 26340 The resolved levels are produced by the Emacs bidi reordering engine
 26341 that implements the UBA, the Unicode Bidirectional Algorithm.  Please
 26342 read the Unicode Standard Annex 9 (UAX#9) for background information
 26343 about these levels.
 26344 
 26345 VPOS is the zero-based number of the current window's screen line
 26346 for which to produce the resolved levels.  If VPOS is nil or omitted,
 26347 it defaults to the screen line of point.  If the window displays a
 26348 header line, VPOS of zero will report on the header line, and first
 26349 line of text in the window will have VPOS of 1.
 26350 
 26351 Value is an array of resolved levels, indexed by glyph number.
 26352 Glyphs are numbered from zero starting from the beginning of the
 26353 screen line, i.e. the left edge of the window for left-to-right lines
 26354 and from the right edge for right-to-left lines.  The resolved levels
 26355 are produced only for the window's text area; text in display margins
 26356 is not included.
 26357 
 26358 If the selected window's display is not up-to-date, or if the specified
 26359 screen line does not display text, this function returns nil.  It is
 26360 highly recommended to bind this function to some simple key, like F8,
 26361 in order to avoid these problems.
 26362 
 26363 This function exists mainly for testing the correctness of the
 26364 Emacs UBA implementation, in particular with the test suite.  */)
 26365   (Lisp_Object vpos)
 26366 {
 26367   struct window *w = XWINDOW (selected_window);
 26368   struct buffer *b = XBUFFER (w->contents);
 26369   int nrow;
 26370   struct glyph_row *row;
 26371 
 26372   if (NILP (vpos))
 26373     {
 26374       int d1, d2, d3, d4, d5;
 26375 
 26376       pos_visible_p (w, PT, &d1, &d2, &d3, &d4, &d5, &nrow);
 26377     }
 26378   else
 26379     {
 26380       CHECK_FIXNUM (vpos);
 26381       nrow = XFIXNUM (vpos);
 26382     }
 26383 
 26384   /* We require up-to-date glyph matrix for this window.  */
 26385   if (w->window_end_valid
 26386       && !windows_or_buffers_changed
 26387       && b
 26388       && !b->clip_changed
 26389       && !b->prevent_redisplay_optimizations_p
 26390       && !window_outdated (w)
 26391       && nrow >= 0
 26392       && nrow < w->current_matrix->nrows
 26393       && (row = MATRIX_ROW (w->current_matrix, nrow))->enabled_p
 26394       && MATRIX_ROW_DISPLAYS_TEXT_P (row))
 26395     {
 26396       struct glyph *g, *e, *g1;
 26397       int nglyphs, i;
 26398       Lisp_Object levels;
 26399 
 26400       if (!row->reversed_p)     /* Left-to-right glyph row.  */
 26401         {
 26402           g = g1 = row->glyphs[TEXT_AREA];
 26403           e = g + row->used[TEXT_AREA];
 26404 
 26405           /* Skip over glyphs at the start of the row that was
 26406              generated by redisplay for its own needs.  */
 26407           while (g < e
 26408                  && NILP (g->object)
 26409                  && g->charpos < 0)
 26410             g++;
 26411           g1 = g;
 26412 
 26413           /* Count the "interesting" glyphs in this row.  */
 26414           for (nglyphs = 0; g < e && !NILP (g->object); g++)
 26415             nglyphs++;
 26416 
 26417           /* Create and fill the array.  */
 26418           levels = make_uninit_vector (nglyphs);
 26419           for (i = 0; g1 < g; i++, g1++)
 26420             ASET (levels, i, make_fixnum (g1->resolved_level));
 26421         }
 26422       else                      /* Right-to-left glyph row.  */
 26423         {
 26424           g = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 26425           e = row->glyphs[TEXT_AREA] - 1;
 26426           while (g > e
 26427                  && NILP (g->object)
 26428                  && g->charpos < 0)
 26429             g--;
 26430           g1 = g;
 26431           for (nglyphs = 0; g > e && !NILP (g->object); g--)
 26432             nglyphs++;
 26433           levels = make_uninit_vector (nglyphs);
 26434           for (i = 0; g1 > g; i++, g1--)
 26435             ASET (levels, i, make_fixnum (g1->resolved_level));
 26436         }
 26437       return levels;
 26438     }
 26439   else
 26440     return Qnil;
 26441 }
 26442 
 26443 
 26444 
 26445 /***********************************************************************
 26446                                Menu Bar
 26447  ***********************************************************************/
 26448 
 26449 /* Redisplay the menu bar in the frame for window W.
 26450 
 26451    The menu bar of X frames that don't have X toolkit support is
 26452    displayed in a special window W->frame->menu_bar_window.
 26453 
 26454    The menu bar of terminal frames is treated specially as far as
 26455    glyph matrices are concerned.  Menu bar lines are not part of
 26456    windows, so the update is done directly on the frame matrix rows
 26457    for the menu bar.  */
 26458 
 26459 static void
 26460 display_menu_bar (struct window *w)
 26461 {
 26462   struct frame *f = XFRAME (WINDOW_FRAME (w));
 26463   struct it it;
 26464   Lisp_Object items;
 26465   int i;
 26466 
 26467   /* Don't do all this for graphical frames.  */
 26468 #ifdef HAVE_NTGUI
 26469   if (FRAME_W32_P (f))
 26470     return;
 26471 #endif
 26472 #if defined (HAVE_PGTK)
 26473   if (FRAME_PGTK_P (f))
 26474     return;
 26475 #endif
 26476 
 26477 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 26478   if (FRAME_X_P (f))
 26479     return;
 26480 #endif
 26481 
 26482 #ifdef HAVE_NS
 26483   if (FRAME_NS_P (f))
 26484     return;
 26485 #endif /* HAVE_NS */
 26486 
 26487 #ifdef HAVE_HAIKU
 26488   if (FRAME_HAIKU_P (f))
 26489     return;
 26490 #endif /* HAVE_HAIKU */
 26491 
 26492 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
 26493   eassert (!FRAME_WINDOW_P (f));
 26494   init_iterator (&it, w, -1, -1, f->desired_matrix->rows, MENU_FACE_ID);
 26495   it.first_visible_x = 0;
 26496   it.last_visible_x = FRAME_PIXEL_WIDTH (f);
 26497 #elif defined (HAVE_X_WINDOWS) /* X without toolkit.  */
 26498   struct window *menu_window = NULL;
 26499   struct face *face = FACE_FROM_ID (f, MENU_FACE_ID);
 26500 
 26501   if (FRAME_WINDOW_P (f))
 26502     {
 26503       /* Menu bar lines are displayed in the desired matrix of the
 26504          dummy window menu_bar_window.  */
 26505       menu_window = XWINDOW (f->menu_bar_window);
 26506       init_iterator (&it, menu_window, -1, -1,
 26507                      menu_window->desired_matrix->rows,
 26508                      MENU_FACE_ID);
 26509     }
 26510   else
 26511 #endif /* not USE_X_TOOLKIT and not USE_GTK */
 26512     {
 26513       /* This is a TTY frame, i.e. character hpos/vpos are used as
 26514          pixel x/y.  */
 26515       init_iterator (&it, w, -1, -1, f->desired_matrix->rows,
 26516                      MENU_FACE_ID);
 26517       it.first_visible_x = 0;
 26518       it.last_visible_x = FRAME_COLS (f);
 26519     }
 26520 
 26521   /* FIXME: This should be controlled by a user option.  See the
 26522      comments in redisplay_tool_bar and display_mode_line about
 26523      this.  */
 26524   it.paragraph_embedding = L2R;
 26525 
 26526   /* Clear all rows of the menu bar.  */
 26527   for (i = 0; i < FRAME_MENU_BAR_LINES (f); ++i)
 26528     {
 26529       struct glyph_row *row = it.glyph_row + i;
 26530       clear_glyph_row (row);
 26531       row->enabled_p = true;
 26532       row->full_width_p = true;
 26533       row->reversed_p = false;
 26534     }
 26535 
 26536   /* Display all items of the menu bar.  */
 26537   items = FRAME_MENU_BAR_ITEMS (it.f);
 26538   for (i = 0; i < ASIZE (items); i += 4)
 26539     {
 26540       Lisp_Object string;
 26541 
 26542       /* Stop at nil string.  */
 26543       string = AREF (items, i + 1);
 26544       if (NILP (string))
 26545         break;
 26546 
 26547       /* Remember where item was displayed.  */
 26548       ASET (items, i + 3, make_fixnum (it.hpos));
 26549 
 26550       /* Display the item, pad with one space.  */
 26551       if (it.current_x < it.last_visible_x)
 26552         display_string (NULL, string, Qnil, 0, 0, &it,
 26553                         SCHARS (string) + 1, 0, 0, STRING_MULTIBYTE (string));
 26554     }
 26555 
 26556   /* Fill out the line with spaces.  */
 26557   if (it.current_x < it.last_visible_x)
 26558     display_string ("", Qnil, Qnil, 0, 0, &it, -1, 0, 0, -1);
 26559 
 26560   /* Compute the total height of the lines.  */
 26561   compute_line_metrics (&it);
 26562   it.glyph_row->full_width_p = true;
 26563   it.glyph_row->continued_p = false;
 26564   it.glyph_row->truncated_on_left_p = false;
 26565   it.glyph_row->truncated_on_right_p = false;
 26566 
 26567 #if defined (HAVE_X_WINDOWS) && !defined (USE_X_TOOLKIT) && !defined (USE_GTK)
 26568   /* Make a 3D menu bar have a shadow at its right end.  */
 26569   extend_face_to_end_of_line (&it);
 26570   if (face->box != FACE_NO_BOX)
 26571     {
 26572       struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
 26573                             + it.glyph_row->used[TEXT_AREA] - 1);
 26574       int box_thickness = face->box_vertical_line_width;
 26575       last->right_box_line_p = true;
 26576       /* Add back the space for the right box line we subtracted in
 26577          init_iterator, since the right_box_line_p flag will make the
 26578          glyph wider.  We actually add only as much space as is
 26579          available for the last glyph of the menu bar and whatever
 26580          space is left beyond it, since that glyph could be only
 26581          partially visible.  */
 26582       if (box_thickness > 0)
 26583         last->pixel_width += max (0, (box_thickness
 26584                                       - (it.current_x - it.last_visible_x)));
 26585     }
 26586 
 26587   /* With the non-toolkit version, modify the menu bar window height
 26588      accordingly.  */
 26589   if (FRAME_WINDOW_P (it.f) && menu_window)
 26590     {
 26591       struct glyph_row *row;
 26592       int delta_height;
 26593 
 26594       row = it.glyph_row;
 26595       delta_height
 26596         = ((row->y + row->height)
 26597            - WINDOW_BOX_HEIGHT_NO_MODE_LINE (menu_window));
 26598 
 26599       if (delta_height != 0)
 26600         {
 26601           FRAME_MENU_BAR_HEIGHT (it.f) += delta_height;
 26602           adjust_frame_size (it.f, -1, -1, 3, false, Qmenu_bar_lines);
 26603         }
 26604     }
 26605 #endif
 26606 }
 26607 
 26608 /* Deep copy of a glyph row, including the glyphs.  */
 26609 static void
 26610 deep_copy_glyph_row (struct glyph_row *to, struct glyph_row *from)
 26611 {
 26612   struct glyph *pointers[1 + LAST_AREA];
 26613   int to_used = to->used[TEXT_AREA];
 26614 
 26615   /* Save glyph pointers of TO.  */
 26616   memcpy (pointers, to->glyphs, sizeof to->glyphs);
 26617 
 26618   /* Do a structure assignment.  */
 26619   *to = *from;
 26620 
 26621   /* Restore original glyph pointers of TO.  */
 26622   memcpy (to->glyphs, pointers, sizeof to->glyphs);
 26623 
 26624   /* Copy the glyphs.  */
 26625   memcpy (to->glyphs[TEXT_AREA], from->glyphs[TEXT_AREA],
 26626           min (from->used[TEXT_AREA], to_used) * sizeof (struct glyph));
 26627 
 26628   /* If we filled only part of the TO row, fill the rest with
 26629      space_glyph (which will display as empty space).  */
 26630   if (to_used > from->used[TEXT_AREA])
 26631     fill_up_frame_row_with_spaces (to, to_used);
 26632 }
 26633 
 26634 /* Display one menu item on a TTY, by overwriting the glyphs in the
 26635    frame F's desired glyph matrix with glyphs produced from the menu
 26636    item text.  Called from term.c to display TTY drop-down menus one
 26637    item at a time.
 26638 
 26639    ITEM_TEXT is the menu item text as a C string.
 26640 
 26641    FACE_ID is the face ID to be used for this menu item.  FACE_ID
 26642    could specify one of 3 faces: a face for an enabled item, a face
 26643    for a disabled item, or a face for a selected item.
 26644 
 26645    X and Y are coordinates of the first glyph in the frame's desired
 26646    matrix to be overwritten by the menu item.  Since this is a TTY, Y
 26647    is the zero-based number of the glyph row and X is the zero-based
 26648    glyph number in the row, starting from left, where to start
 26649    displaying the item.
 26650 
 26651    SUBMENU means this menu item drops down a submenu, which
 26652    should be indicated by displaying a proper visual cue after the
 26653    item text.  */
 26654 
 26655 void
 26656 display_tty_menu_item (const char *item_text, int width, int face_id,
 26657                        int x, int y, bool submenu)
 26658 {
 26659   struct it it;
 26660   struct frame *f = SELECTED_FRAME ();
 26661   struct window *w = XWINDOW (f->selected_window);
 26662   struct glyph_row *row;
 26663   size_t item_len = strlen (item_text);
 26664 
 26665   eassert (FRAME_TERMCAP_P (f));
 26666 
 26667   /* Don't write beyond the matrix's last row.  This can happen for
 26668      TTY screens that are not high enough to show the entire menu.
 26669      (This is actually a bit of defensive programming, as
 26670      tty_menu_display already limits the number of menu items to one
 26671      less than the number of screen lines.)  */
 26672   if (y >= f->desired_matrix->nrows)
 26673     return;
 26674 
 26675   init_iterator (&it, w, -1, -1, f->desired_matrix->rows + y, MENU_FACE_ID);
 26676   it.first_visible_x = 0;
 26677   it.last_visible_x = FRAME_COLS (f) - 1;
 26678   row = it.glyph_row;
 26679   /* Start with the row contents from the current matrix.  */
 26680   deep_copy_glyph_row (row, f->current_matrix->rows + y);
 26681   bool saved_width = row->full_width_p;
 26682   row->full_width_p = true;
 26683   bool saved_reversed = row->reversed_p;
 26684   row->reversed_p = false;
 26685   row->enabled_p = true;
 26686 
 26687   /* Arrange for the menu item glyphs to start at (X,Y) and have the
 26688      desired face.  */
 26689   eassert (x < f->desired_matrix->matrix_w);
 26690   it.current_x = it.hpos = x;
 26691   it.current_y = it.vpos = y;
 26692   int saved_used = row->used[TEXT_AREA];
 26693   bool saved_truncated = row->truncated_on_right_p;
 26694   row->used[TEXT_AREA] = x;
 26695   it.face_id = face_id;
 26696   it.line_wrap = TRUNCATE;
 26697 
 26698   /* FIXME: This should be controlled by a user option.  See the
 26699      comments in redisplay_tool_bar and display_mode_line about this.
 26700      Also, if paragraph_embedding could ever be R2L, changes will be
 26701      needed to avoid shifting to the right the row characters in
 26702      term.c:append_glyph.  */
 26703   it.paragraph_embedding = L2R;
 26704 
 26705   /* Pad with a space on the left.  */
 26706   display_string (" ", Qnil, Qnil, 0, 0, &it, 1, 0, FRAME_COLS (f) - 1, -1);
 26707   width--;
 26708   /* Display the menu item, pad with spaces to WIDTH.  */
 26709   if (submenu)
 26710     {
 26711       display_string (item_text, Qnil, Qnil, 0, 0, &it,
 26712                       item_len, 0, FRAME_COLS (f) - 1, -1);
 26713       width -= item_len;
 26714       /* Indicate with " >" that there's a submenu.  */
 26715       display_string (" >", Qnil, Qnil, 0, 0, &it, width, 0,
 26716                       FRAME_COLS (f) - 1, -1);
 26717     }
 26718   else
 26719     display_string (item_text, Qnil, Qnil, 0, 0, &it,
 26720                     width, 0, FRAME_COLS (f) - 1, -1);
 26721 
 26722   row->used[TEXT_AREA] = max (saved_used, row->used[TEXT_AREA]);
 26723   row->truncated_on_right_p = saved_truncated;
 26724   row->hash = row_hash (row);
 26725   row->full_width_p = saved_width;
 26726   row->reversed_p = saved_reversed;
 26727 }
 26728 
 26729 /***********************************************************************
 26730                               Mode Line
 26731  ***********************************************************************/
 26732 
 26733 /* Redisplay mode lines in the window tree whose root is WINDOW.
 26734    If FORCE, redisplay mode lines unconditionally.
 26735    Otherwise, redisplay only mode lines that are garbaged.  Value is
 26736    the number of windows whose mode lines were redisplayed.  */
 26737 
 26738 static int
 26739 redisplay_mode_lines (Lisp_Object window, bool force)
 26740 {
 26741   int nwindows = 0;
 26742 
 26743   while (!NILP (window))
 26744     {
 26745       struct window *w = XWINDOW (window);
 26746 
 26747       if (WINDOWP (w->contents))
 26748         nwindows += redisplay_mode_lines (w->contents, force);
 26749       else if (force
 26750                || FRAME_GARBAGED_P (XFRAME (w->frame))
 26751                || !MATRIX_MODE_LINE_ROW (w->current_matrix)->enabled_p)
 26752         {
 26753           struct text_pos lpoint;
 26754           struct buffer *old = current_buffer;
 26755 
 26756           /* Set the window's buffer for the mode line display.  */
 26757           SET_TEXT_POS (lpoint, PT, PT_BYTE);
 26758           set_buffer_internal_1 (XBUFFER (w->contents));
 26759 
 26760           /* Point refers normally to the selected window.  For any
 26761              other window, set up appropriate value.  */
 26762           if (!EQ (window, selected_window))
 26763             {
 26764               struct text_pos pt;
 26765 
 26766               CLIP_TEXT_POS_FROM_MARKER (pt, w->pointm);
 26767               TEMP_SET_PT_BOTH (CHARPOS (pt), BYTEPOS (pt));
 26768             }
 26769 
 26770           /* Display mode lines.  */
 26771           clear_glyph_matrix (w->desired_matrix);
 26772           if (display_mode_lines (w))
 26773             ++nwindows;
 26774 
 26775           /* Restore old settings.  */
 26776           set_buffer_internal_1 (old);
 26777           TEMP_SET_PT_BOTH (CHARPOS (lpoint), BYTEPOS (lpoint));
 26778         }
 26779 
 26780       window = w->next;
 26781     }
 26782 
 26783   return nwindows;
 26784 }
 26785 
 26786 
 26787 /* Display the mode line, the header line, and the tab-line of window
 26788    W.  Value is the sum number of mode lines, header lines, and tab
 26789    lines actually displayed.  */
 26790 
 26791 static int
 26792 display_mode_lines (struct window *w)
 26793 {
 26794   Lisp_Object old_selected_window = selected_window;
 26795   Lisp_Object new_frame = w->frame;
 26796   specpdl_ref count = SPECPDL_INDEX ();
 26797   int n = 0;
 26798 
 26799   record_unwind_protect (restore_selected_window, selected_window);
 26800   record_unwind_protect
 26801     (restore_frame_selected_window, XFRAME (new_frame)->selected_window);
 26802 
 26803   if (window_wants_mode_line (w))
 26804     {
 26805       Lisp_Object window;
 26806       Lisp_Object default_help
 26807         = buffer_local_value (Qmode_line_default_help_echo, w->contents);
 26808 
 26809       /* Set up mode line help echo.  Do this before selecting w so it
 26810          can reasonably tell whether a mouse click will select w.  */
 26811       XSETWINDOW (window, w);
 26812       if (FUNCTIONP (default_help))
 26813         wset_mode_line_help_echo (w, safe_call1 (default_help, window));
 26814       else if (STRINGP (default_help))
 26815         wset_mode_line_help_echo (w, default_help);
 26816       else
 26817         wset_mode_line_help_echo (w, Qnil);
 26818     }
 26819 
 26820   selected_frame = new_frame;
 26821   /* FIXME: If we were to allow the mode-line's computation changing the buffer
 26822      or window's point, then we'd need select_window_1 here as well.  */
 26823   XSETWINDOW (selected_window, w);
 26824   XFRAME (new_frame)->selected_window = selected_window;
 26825 
 26826   /* These will be set while the mode line specs are processed.  */
 26827   line_number_displayed = false;
 26828   w->column_number_displayed = -1;
 26829 
 26830   if (window_wants_mode_line (w))
 26831     {
 26832       Lisp_Object window_mode_line_format
 26833         = window_parameter (w, Qmode_line_format);
 26834       struct window *sel_w = XWINDOW (old_selected_window);
 26835 
 26836       /* Select mode line face based on the real selected window.  */
 26837       display_mode_line (w,
 26838                          CURRENT_MODE_LINE_ACTIVE_FACE_ID_3 (sel_w, sel_w, w),
 26839                          NILP (window_mode_line_format)
 26840                          ? BVAR (current_buffer, mode_line_format)
 26841                          : window_mode_line_format);
 26842       ++n;
 26843     }
 26844 
 26845   if (window_wants_tab_line (w))
 26846     {
 26847       Lisp_Object window_tab_line_format
 26848         = window_parameter (w, Qtab_line_format);
 26849 
 26850       display_mode_line (w, TAB_LINE_FACE_ID,
 26851                          NILP (window_tab_line_format)
 26852                          ? BVAR (current_buffer, tab_line_format)
 26853                          : window_tab_line_format);
 26854       ++n;
 26855     }
 26856 
 26857   if (window_wants_header_line (w))
 26858     {
 26859       Lisp_Object window_header_line_format
 26860         = window_parameter (w, Qheader_line_format);
 26861 
 26862       display_mode_line (w, HEADER_LINE_FACE_ID,
 26863                          NILP (window_header_line_format)
 26864                          ? BVAR (current_buffer, header_line_format)
 26865                          : window_header_line_format);
 26866       ++n;
 26867     }
 26868 
 26869   unbind_to (count, Qnil);
 26870 
 26871   if (n > 0)
 26872     w->must_be_updated_p = true;
 26873   return n;
 26874 }
 26875 
 26876 
 26877 /* Display mode or header/tab line of window W.  FACE_ID specifies
 26878    which line to display; it is either MODE_LINE_ACTIVE_FACE_ID,
 26879    HEADER_LINE_FACE_ID or TAB_LINE_FACE_ID.  FORMAT is the
 26880    mode/header/tab line format to display.  Value is the pixel height
 26881    of the mode/header/tab line displayed.  */
 26882 
 26883 static int
 26884 display_mode_line (struct window *w, enum face_id face_id, Lisp_Object format)
 26885 {
 26886   struct it it;
 26887   struct face *face;
 26888   specpdl_ref count = SPECPDL_INDEX ();
 26889 
 26890   init_iterator (&it, w, -1, -1, NULL, face_id);
 26891   /* Don't extend on a previously drawn mode-line.
 26892      This may happen if called from pos_visible_p.  */
 26893   it.glyph_row->enabled_p = false;
 26894   prepare_desired_row (w, it.glyph_row, true);
 26895 
 26896   it.glyph_row->mode_line_p = true;
 26897   if (face_id == TAB_LINE_FACE_ID)
 26898     {
 26899       it.glyph_row->tab_line_p = true;
 26900       w->desired_matrix->tab_line_p = true;
 26901     }
 26902   else if (face_id == HEADER_LINE_FACE_ID)
 26903     w->desired_matrix->header_line_p = true;
 26904 
 26905   /* FIXME: This should be controlled by a user option.  But
 26906      supporting such an option is not trivial, since the mode line is
 26907      made up of many separate strings.  */
 26908   it.paragraph_embedding = L2R;
 26909 
 26910   record_unwind_protect (unwind_format_mode_line,
 26911                          format_mode_line_unwind_data (NULL, NULL,
 26912                                                        Qnil, false));
 26913 
 26914   /* Temporarily make frame's keyboard the current kboard so that
 26915      kboard-local variables in the mode_line_format will get the right
 26916      values.  */
 26917   push_kboard (FRAME_KBOARD (it.f));
 26918   record_unwind_save_match_data ();
 26919 
 26920   if (NILP (Vmode_line_compact)
 26921       || face_id == HEADER_LINE_FACE_ID || face_id == TAB_LINE_FACE_ID)
 26922     {
 26923       mode_line_target = MODE_LINE_DISPLAY;
 26924       display_mode_element (&it, 0, 0, 0, format, Qnil, false);
 26925     }
 26926   else
 26927     {
 26928       Lisp_Object mode_string = Fformat_mode_line (format, Qnil, Qnil, Qnil);
 26929       if (EQ (Vmode_line_compact, Qlong)
 26930           && WINDOW_TOTAL_COLS (w) >= SCHARS (mode_string))
 26931         {
 26932           /* The window is wide enough; just display the mode line we
 26933              just computed. */
 26934           display_string (NULL, mode_string, Qnil,
 26935                           0, 0, &it, 0, 0, 0,
 26936                           STRING_MULTIBYTE (mode_string));
 26937         }
 26938       else
 26939         {
 26940           /* Compress the mode line. */
 26941           ptrdiff_t i = 0, i_byte = 0, start = 0;
 26942           int prev = 0;
 26943 
 26944           while (i < SCHARS (mode_string))
 26945             {
 26946               int c = fetch_string_char_advance (mode_string, &i, &i_byte);
 26947               if (c == ' ' && prev == ' ')
 26948                 {
 26949                   display_string (NULL,
 26950                                   Fsubstring (mode_string, make_fixnum (start),
 26951                                               make_fixnum (i - 1)),
 26952                                   Qnil, 0, 0, &it, 0, 0, 0,
 26953                                   STRING_MULTIBYTE (mode_string));
 26954                   /* Skip past the rest of the space characters. */
 26955                   while (c == ' ' && i < SCHARS (mode_string))
 26956                       c = fetch_string_char_advance (mode_string, &i, &i_byte);
 26957                   start = i - 1;
 26958                 }
 26959               prev = c;
 26960             }
 26961 
 26962           /* Display the final bit. */
 26963           if (start < i)
 26964             display_string (NULL,
 26965                             Fsubstring (mode_string, make_fixnum (start),
 26966                                         make_fixnum (i)),
 26967                             Qnil, 0, 0, &it, 0, 0, 0,
 26968                             STRING_MULTIBYTE (mode_string));
 26969         }
 26970     }
 26971   pop_kboard ();
 26972 
 26973   unbind_to (count, Qnil);
 26974 
 26975   /* Fill up with spaces.  */
 26976   display_string (" ", Qnil, Qnil, 0, 0, &it, 10000, -1, -1, 0);
 26977 
 26978   compute_line_metrics (&it);
 26979   it.glyph_row->full_width_p = true;
 26980   it.glyph_row->continued_p = false;
 26981   it.glyph_row->truncated_on_left_p = false;
 26982   it.glyph_row->truncated_on_right_p = false;
 26983 
 26984   /* Make a 3D mode-line have a shadow at its right end.  */
 26985   face = FACE_FROM_ID (it.f, face_id);
 26986   extend_face_to_end_of_line (&it);
 26987   if (face->box != FACE_NO_BOX)
 26988     {
 26989       struct glyph *last = (it.glyph_row->glyphs[TEXT_AREA]
 26990                             + it.glyph_row->used[TEXT_AREA] - 1);
 26991       int box_thickness = face->box_vertical_line_width;
 26992       last->right_box_line_p = true;
 26993       /* Add back the space for the right box line we subtracted in
 26994          init_iterator, since the right_box_line_p flag will make the
 26995          glyph wider.  We actually add only as much space as is
 26996          available for the last glyph of the modeline and whatever
 26997          space is left beyond it, since that glyph could be only
 26998          partially visible */
 26999       if (box_thickness > 0)
 27000         last->pixel_width += max (0, (box_thickness
 27001                                       - (it.current_x - it.last_visible_x)));
 27002     }
 27003 
 27004   return it.glyph_row->height;
 27005 }
 27006 
 27007 /* Move element ELT in LIST to the front of LIST.
 27008    Return the updated list.  */
 27009 
 27010 static Lisp_Object
 27011 move_elt_to_front (Lisp_Object elt, Lisp_Object list)
 27012 {
 27013   register Lisp_Object tail, prev;
 27014   register Lisp_Object tem;
 27015 
 27016   tail = list;
 27017   prev = Qnil;
 27018   while (CONSP (tail))
 27019     {
 27020       tem = XCAR (tail);
 27021 
 27022       if (EQ (elt, tem))
 27023         {
 27024           /* Splice out the link TAIL.  */
 27025           if (NILP (prev))
 27026             list = XCDR (tail);
 27027           else
 27028             Fsetcdr (prev, XCDR (tail));
 27029 
 27030           /* Now make it the first.  */
 27031           Fsetcdr (tail, list);
 27032           return tail;
 27033         }
 27034       else
 27035         prev = tail;
 27036       tail = XCDR (tail);
 27037       maybe_quit ();
 27038     }
 27039 
 27040   /* Not found--return unchanged LIST.  */
 27041   return list;
 27042 }
 27043 
 27044 /* Subroutine to call Fset_text_properties through
 27045    internal_condition_case_n.  ARGS are the arguments of
 27046    Fset_text_properties, in order.  */
 27047 
 27048 static Lisp_Object
 27049 safe_set_text_properties (ptrdiff_t nargs, Lisp_Object *args)
 27050 {
 27051   eassert (nargs == 4);
 27052   return Fset_text_properties (args[0], args[1], args[2], args[3]);
 27053 }
 27054 
 27055 /* Contribute ELT to the mode line for window IT->w.  How it
 27056    translates into text depends on its data type.
 27057 
 27058    IT describes the display environment in which we display, as usual.
 27059 
 27060    DEPTH is the depth in recursion.  It is used to prevent
 27061    infinite recursion here.
 27062 
 27063    FIELD_WIDTH is the number of characters the display of ELT should
 27064    occupy in the mode line, and PRECISION is the maximum number of
 27065    characters to display from ELT's representation.  See
 27066    display_string for details.
 27067 
 27068    Returns the hpos of the end of the text generated by ELT.
 27069 
 27070    PROPS is a property list to add to any string we encounter.
 27071 
 27072    If RISKY, remove (disregard) any properties in any string
 27073    we encounter, and ignore :eval and :propertize.
 27074 
 27075    The global variable `mode_line_target' determines whether the
 27076    output is passed to `store_mode_line_noprop',
 27077    `store_mode_line_string', or `display_string'.  */
 27078 
 27079 static int
 27080 display_mode_element (struct it *it, int depth, int field_width, int precision,
 27081                       Lisp_Object elt, Lisp_Object props, bool risky)
 27082 {
 27083   int n = 0, field, prec;
 27084   bool literal = false;
 27085 
 27086  tail_recurse:
 27087   if (depth > 100)
 27088     elt = build_string ("*too-deep*");
 27089 
 27090   depth++;
 27091 
 27092   switch (XTYPE (elt))
 27093     {
 27094     case Lisp_String:
 27095       {
 27096         /* A string: output it and check for %-constructs within it.  */
 27097         unsigned char c;
 27098         ptrdiff_t offset = 0;
 27099 
 27100         if (SCHARS (elt) > 0
 27101             && (!NILP (props) || risky))
 27102           {
 27103             Lisp_Object oprops, aelt;
 27104             oprops = Ftext_properties_at (make_fixnum (0), elt);
 27105 
 27106             /* If the starting string's properties are not what
 27107                we want, translate the string.  Also, if the string
 27108                is risky, do that anyway.  */
 27109 
 27110             if (NILP (Fequal (props, oprops)) || risky)
 27111               {
 27112                 /* If the starting string has properties,
 27113                    merge the specified ones onto the existing ones.  */
 27114                 if (! NILP (oprops) && !risky)
 27115                   {
 27116                     Lisp_Object tem;
 27117 
 27118                     oprops = Fcopy_sequence (oprops);
 27119                     tem = props;
 27120                     while (CONSP (tem))
 27121                       {
 27122                         oprops = plist_put (oprops, XCAR (tem),
 27123                                             XCAR (XCDR (tem)));
 27124                         tem = XCDR (XCDR (tem));
 27125                       }
 27126                     props = oprops;
 27127                   }
 27128 
 27129                 aelt = Fassoc (elt, mode_line_proptrans_alist, Qnil);
 27130                 if (! NILP (aelt) && !NILP (Fequal (props, XCDR (aelt))))
 27131                   {
 27132                     /* AELT is what we want.  Move it to the front
 27133                        without consing.  */
 27134                     elt = XCAR (aelt);
 27135                     mode_line_proptrans_alist
 27136                       = move_elt_to_front (aelt, mode_line_proptrans_alist);
 27137                   }
 27138                 else
 27139                   {
 27140                     Lisp_Object tem;
 27141 
 27142                     /* If AELT has the wrong props, it is useless.
 27143                        so get rid of it.  */
 27144                     if (! NILP (aelt))
 27145                       mode_line_proptrans_alist
 27146                         = Fdelq (aelt, mode_line_proptrans_alist);
 27147 
 27148                     elt = Fcopy_sequence (elt);
 27149                     /* PROPS might cause set-text-properties to signal
 27150                        an error, so we call it via internal_condition_case_n,
 27151                        to avoid an infloop in redisplay due to the error.  */
 27152                     internal_condition_case_n (safe_set_text_properties,
 27153                                                4,
 27154                                                ((Lisp_Object [])
 27155                                                {make_fixnum (0),
 27156                                                    Flength (elt),
 27157                                                    props,
 27158                                                    elt}),
 27159                                                Qt, safe_eval_handler);
 27160                     /* Add this item to mode_line_proptrans_alist.  */
 27161                     mode_line_proptrans_alist
 27162                       = Fcons (Fcons (elt, props),
 27163                                mode_line_proptrans_alist);
 27164                     /* Truncate mode_line_proptrans_alist
 27165                        to at most 50 elements.  */
 27166                     tem = Fnthcdr (make_fixnum (50),
 27167                                    mode_line_proptrans_alist);
 27168                     if (! NILP (tem))
 27169                       XSETCDR (tem, Qnil);
 27170                   }
 27171               }
 27172           }
 27173 
 27174         offset = 0;
 27175 
 27176         if (literal)
 27177           {
 27178             prec = precision - n;
 27179             switch (mode_line_target)
 27180               {
 27181               case MODE_LINE_NOPROP:
 27182               case MODE_LINE_TITLE:
 27183                 n += store_mode_line_noprop (SSDATA (elt), -1, prec);
 27184                 break;
 27185               case MODE_LINE_STRING:
 27186                 n += store_mode_line_string (NULL, elt, true, 0, prec, Qnil);
 27187                 break;
 27188               case MODE_LINE_DISPLAY:
 27189                 n += display_string (NULL, elt, Qnil, 0, 0, it,
 27190                                      0, prec, 0, STRING_MULTIBYTE (elt));
 27191                 break;
 27192               }
 27193 
 27194             break;
 27195           }
 27196 
 27197         /* Handle the non-literal case.  */
 27198 
 27199         while ((precision <= 0 || n < precision)
 27200                && SREF (elt, offset) != 0
 27201                && (mode_line_target != MODE_LINE_DISPLAY
 27202                    || it->current_x < it->last_visible_x))
 27203           {
 27204             ptrdiff_t last_offset = offset;
 27205 
 27206             /* Advance to end of string or next format specifier.  */
 27207             while ((c = SREF (elt, offset++)) != '\0' && c != '%')
 27208               ;
 27209 
 27210             if (offset - 1 != last_offset)
 27211               {
 27212                 ptrdiff_t nchars, nbytes;
 27213 
 27214                 /* Output to end of string or up to '%'.  Field width
 27215                    is length of string.  Don't output more than
 27216                    PRECISION allows us.  */
 27217                 offset--;
 27218 
 27219                 prec = c_string_width (SDATA (elt) + last_offset,
 27220                                        offset - last_offset, precision - n,
 27221                                        &nchars, &nbytes);
 27222 
 27223                 switch (mode_line_target)
 27224                   {
 27225                   case MODE_LINE_NOPROP:
 27226                   case MODE_LINE_TITLE:
 27227                     n += store_mode_line_noprop (SSDATA (elt) + last_offset, 0, prec);
 27228                     break;
 27229                   case MODE_LINE_STRING:
 27230                     {
 27231                       ptrdiff_t bytepos = last_offset;
 27232                       ptrdiff_t charpos = string_byte_to_char (elt, bytepos);
 27233                       ptrdiff_t endpos = (precision <= 0
 27234                                           ? string_byte_to_char (elt, offset)
 27235                                           : charpos + nchars);
 27236                       Lisp_Object mode_string
 27237                         = Fsubstring (elt, make_fixnum (charpos),
 27238                                       make_fixnum (endpos));
 27239                       n += store_mode_line_string (NULL, mode_string, false,
 27240                                                    0, 0, Qnil);
 27241                     }
 27242                     break;
 27243                   case MODE_LINE_DISPLAY:
 27244                     {
 27245                       ptrdiff_t bytepos = last_offset;
 27246                       ptrdiff_t charpos = string_byte_to_char (elt, bytepos);
 27247 
 27248                       if (precision <= 0)
 27249                         nchars = string_byte_to_char (elt, offset) - charpos;
 27250                       n += display_string (NULL, elt, Qnil, 0, charpos,
 27251                                            it, 0, nchars, 0,
 27252                                            STRING_MULTIBYTE (elt));
 27253                     }
 27254                     break;
 27255                   }
 27256               }
 27257             else /* c == '%' */
 27258               {
 27259                 ptrdiff_t percent_position = offset;
 27260 
 27261                 /* Get the specified minimum width.  Zero means
 27262                    don't pad.  */
 27263                 field = 0;
 27264                 while ((c = SREF (elt, offset++)) >= '0' && c <= '9')
 27265                   field = field * 10 + c - '0';
 27266 
 27267                 /* Don't pad beyond the total padding allowed.  */
 27268                 if (field_width - n > 0 && field > field_width - n)
 27269                   field = field_width - n;
 27270 
 27271                 /* Note that either PRECISION <= 0 or N < PRECISION.  */
 27272                 prec = precision - n;
 27273 
 27274                 if (c == 'M')
 27275                   n += display_mode_element (it, depth, field, prec,
 27276                                              Vglobal_mode_string, props,
 27277                                              risky);
 27278                 else if (c != 0)
 27279                   {
 27280                     bool multibyte;
 27281                     ptrdiff_t bytepos, charpos;
 27282                     const char *spec;
 27283                     Lisp_Object string;
 27284 
 27285                     bytepos = percent_position;
 27286                     charpos = (STRING_MULTIBYTE (elt)
 27287                                ? string_byte_to_char (elt, bytepos)
 27288                                : bytepos);
 27289                     spec = decode_mode_spec (it->w, c, field, &string);
 27290                     eassert (NILP (string) || STRINGP (string));
 27291                     multibyte = !NILP (string) && STRING_MULTIBYTE (string);
 27292                     /* Non-ASCII characters in SPEC should cause mode-line
 27293                        element be displayed as a multibyte string.  */
 27294                     ptrdiff_t nbytes = strlen (spec);
 27295                     ptrdiff_t nchars, mb_nbytes;
 27296                     parse_str_as_multibyte ((const unsigned char *)spec, nbytes,
 27297                                             &nchars, &mb_nbytes);
 27298                     if (!(nbytes == nchars || nbytes != mb_nbytes))
 27299                       multibyte = true;
 27300 
 27301                     switch (mode_line_target)
 27302                       {
 27303                       case MODE_LINE_NOPROP:
 27304                       case MODE_LINE_TITLE:
 27305                         n += store_mode_line_noprop (spec, field, prec);
 27306                         break;
 27307                       case MODE_LINE_STRING:
 27308                         {
 27309                           Lisp_Object tem = build_string (spec);
 27310                           props = Ftext_properties_at (make_fixnum (charpos), elt);
 27311                           /* Should only keep face property in props */
 27312                           n += store_mode_line_string (NULL, tem, false,
 27313                                                        field, prec, props);
 27314                         }
 27315                         break;
 27316                       case MODE_LINE_DISPLAY:
 27317                         {
 27318                           int nglyphs_before, nwritten;
 27319 
 27320                           nglyphs_before = it->glyph_row->used[TEXT_AREA];
 27321                           nwritten = display_string (spec, string, elt,
 27322                                                      charpos, 0, it,
 27323                                                      field, prec, 0,
 27324                                                      multibyte);
 27325 
 27326                           /* Assign to the glyphs written above the
 27327                              string where the `%x' came from, position
 27328                              of the `%'.  */
 27329                           if (nwritten > 0)
 27330                             {
 27331                               struct glyph *glyph
 27332                                 = (it->glyph_row->glyphs[TEXT_AREA]
 27333                                    + nglyphs_before);
 27334                               int i;
 27335 
 27336                               for (i = 0; i < nwritten; ++i)
 27337                                 {
 27338                                   glyph[i].object = elt;
 27339                                   glyph[i].charpos = charpos;
 27340                                 }
 27341 
 27342                               n += nwritten;
 27343                             }
 27344                         }
 27345                         break;
 27346                       }
 27347                   }
 27348                 else /* c == 0 */
 27349                   break;
 27350               }
 27351           }
 27352       }
 27353       break;
 27354 
 27355     case Lisp_Symbol:
 27356       /* A symbol: process the value of the symbol recursively
 27357          as if it appeared here directly.  Avoid error if symbol void.
 27358          Special case: if value of symbol is a string, output the string
 27359          literally.  */
 27360       {
 27361         register Lisp_Object tem;
 27362 
 27363         /* If the variable is not marked as risky to set
 27364            then its contents are risky to use.  */
 27365         if (NILP (Fget (elt, Qrisky_local_variable)))
 27366           risky = true;
 27367 
 27368         tem = Fboundp (elt);
 27369         if (!NILP (tem))
 27370           {
 27371             tem = Fsymbol_value (elt);
 27372             /* If value is a string, output that string literally:
 27373                don't check for % within it.  */
 27374             if (STRINGP (tem))
 27375               literal = true;
 27376 
 27377             if (!EQ (tem, elt))
 27378               {
 27379                 /* Give up right away for nil or t.  */
 27380                 elt = tem;
 27381                 goto tail_recurse;
 27382               }
 27383           }
 27384       }
 27385       break;
 27386 
 27387     case Lisp_Cons:
 27388       {
 27389         register Lisp_Object car, tem;
 27390 
 27391         /* A cons cell: five distinct cases.
 27392            If first element is :eval or :propertize, do something special.
 27393            If first element is a string or a cons, process all the elements
 27394            and effectively concatenate them.
 27395            If first element is a negative number, truncate displaying cdr to
 27396            at most that many characters.  If positive, pad (with spaces)
 27397            to at least that many characters.
 27398            If first element is a symbol, process the cadr or caddr recursively
 27399            according to whether the symbol's value is non-nil or nil.  */
 27400         car = XCAR (elt);
 27401         if (EQ (car, QCeval))
 27402           {
 27403             /* An element of the form (:eval FORM) means evaluate FORM
 27404                and use the result as mode line elements.  */
 27405 
 27406             if (risky)
 27407               break;
 27408 
 27409             if (CONSP (XCDR (elt)))
 27410               {
 27411                 Lisp_Object spec;
 27412                 spec = safe__eval (true, XCAR (XCDR (elt)));
 27413                 /* The :eval form could delete the frame stored in the
 27414                    iterator, which will cause a crash if we try to
 27415                    access faces and other fields (e.g., FRAME_KBOARD)
 27416                    on that frame.  This is a nonsensical thing to do,
 27417                    and signaling an error from redisplay might be
 27418                    dangerous, but we cannot continue with an invalid frame.  */
 27419                 if (!FRAME_LIVE_P (it->f))
 27420                   signal_error (":eval deleted the frame being displayed", elt);
 27421                 n += display_mode_element (it, depth, field_width - n,
 27422                                            precision - n, spec, props,
 27423                                            risky);
 27424               }
 27425           }
 27426         else if (EQ (car, QCpropertize))
 27427           {
 27428             /* An element of the form (:propertize ELT PROPS...)
 27429                means display ELT but applying properties PROPS.  */
 27430 
 27431             if (risky)
 27432               break;
 27433 
 27434             if (CONSP (XCDR (elt)))
 27435               n += display_mode_element (it, depth, field_width - n,
 27436                                          precision - n, XCAR (XCDR (elt)),
 27437                                          XCDR (XCDR (elt)), risky);
 27438           }
 27439         else if (SYMBOLP (car))
 27440           {
 27441             tem = Fboundp (car);
 27442             elt = XCDR (elt);
 27443             if (!CONSP (elt))
 27444               goto invalid;
 27445             /* elt is now the cdr, and we know it is a cons cell.
 27446                Use its car if CAR has a non-nil value.  */
 27447             if (!NILP (tem))
 27448               {
 27449                 tem = Fsymbol_value (car);
 27450                 if (!NILP (tem))
 27451                   {
 27452                     elt = XCAR (elt);
 27453                     goto tail_recurse;
 27454                   }
 27455               }
 27456             /* Symbol's value is nil (or symbol is unbound)
 27457                Get the cddr of the original list
 27458                and if possible find the caddr and use that.  */
 27459             elt = XCDR (elt);
 27460             if (NILP (elt))
 27461               break;
 27462             else if (!CONSP (elt))
 27463               goto invalid;
 27464             elt = XCAR (elt);
 27465             goto tail_recurse;
 27466           }
 27467         else if (FIXNUMP (car))
 27468           {
 27469             register int lim = XFIXNUM (car);
 27470             elt = XCDR (elt);
 27471             if (lim < 0)
 27472               {
 27473                 /* Negative int means reduce maximum width.  */
 27474                 if (precision <= 0)
 27475                   precision = -lim;
 27476                 else
 27477                   precision = min (precision, -lim);
 27478               }
 27479             else if (lim > 0)
 27480               {
 27481                 /* Padding specified.  Don't let it be more than
 27482                    current maximum.  */
 27483                 if (precision > 0)
 27484                   lim = min (precision, lim);
 27485 
 27486                 /* If that's more padding than already wanted, queue it.
 27487                    But don't reduce padding already specified even if
 27488                    that is beyond the current truncation point.  */
 27489                 field_width = max (lim, field_width);
 27490               }
 27491             goto tail_recurse;
 27492           }
 27493         else if (STRINGP (car) || CONSP (car))
 27494           FOR_EACH_TAIL_SAFE (elt)
 27495             {
 27496               if (0 < precision && precision <= n)
 27497                 break;
 27498               n += display_mode_element (it, depth,
 27499                                          /* Pad after only the last
 27500                                             list element.  */
 27501                                          (! CONSP (XCDR (elt))
 27502                                           ? field_width - n
 27503                                           : 0),
 27504                                          precision - n, XCAR (elt),
 27505                                          props, risky);
 27506             }
 27507       }
 27508       break;
 27509 
 27510     default:
 27511     invalid:
 27512       elt = build_string ("*invalid*");
 27513       goto tail_recurse;
 27514     }
 27515 
 27516   /* Pad to FIELD_WIDTH.  */
 27517   if (field_width > 0 && n < field_width)
 27518     {
 27519       switch (mode_line_target)
 27520         {
 27521         case MODE_LINE_NOPROP:
 27522         case MODE_LINE_TITLE:
 27523           n += store_mode_line_noprop ("", field_width - n, 0);
 27524           break;
 27525         case MODE_LINE_STRING:
 27526           n += store_mode_line_string ("", Qnil, false, field_width - n, 0,
 27527                                        Qnil);
 27528           break;
 27529         case MODE_LINE_DISPLAY:
 27530           n += display_string ("", Qnil, Qnil, 0, 0, it, field_width - n,
 27531                                0, 0, 0);
 27532           break;
 27533         }
 27534     }
 27535 
 27536   return n;
 27537 }
 27538 
 27539 /* Store a mode-line string element in mode_line_string_list.
 27540 
 27541    If STRING is non-null, display that C string.  Otherwise, the Lisp
 27542    string LISP_STRING is displayed.
 27543 
 27544    FIELD_WIDTH is the minimum number of output glyphs to produce.
 27545    If STRING has fewer characters than FIELD_WIDTH, pad to the right
 27546    with spaces.  FIELD_WIDTH <= 0 means don't pad.
 27547 
 27548    PRECISION is the maximum number of characters to output from
 27549    STRING.  PRECISION <= 0  means don't truncate the string.
 27550 
 27551    If COPY_STRING, make a copy of LISP_STRING before adding
 27552    properties to the string.
 27553 
 27554    PROPS are the properties to add to the string.
 27555    The mode_line_string_face face property is always added to the string.
 27556  */
 27557 
 27558 static int
 27559 store_mode_line_string (const char *string, Lisp_Object lisp_string,
 27560                         bool copy_string,
 27561                         int field_width, int precision, Lisp_Object props)
 27562 {
 27563   ptrdiff_t len;
 27564   int n = 0;
 27565 
 27566   if (string != NULL)
 27567     {
 27568       len = strnlen (string, precision <= 0 ? SIZE_MAX : precision);
 27569       lisp_string = make_string (string, len);
 27570       if (NILP (props))
 27571         props = mode_line_string_face_prop;
 27572       else if (!NILP (mode_line_string_face))
 27573         {
 27574           Lisp_Object face = plist_get (props, Qface);
 27575           props = Fcopy_sequence (props);
 27576           if (NILP (face))
 27577             face = mode_line_string_face;
 27578           else
 27579             face = list2 (face, mode_line_string_face);
 27580           props = plist_put (props, Qface, face);
 27581         }
 27582       Fadd_text_properties (make_fixnum (0), make_fixnum (len),
 27583                             props, lisp_string);
 27584     }
 27585   else
 27586     {
 27587       len = SCHARS (lisp_string);
 27588       if (precision > 0 && len > precision)
 27589         {
 27590           len = precision;
 27591           lisp_string = Fsubstring (lisp_string, make_fixnum (0), make_fixnum (len));
 27592           precision = -1;
 27593         }
 27594       if (!NILP (mode_line_string_face))
 27595         {
 27596           Lisp_Object face;
 27597           if (NILP (props))
 27598             props = Ftext_properties_at (make_fixnum (0), lisp_string);
 27599           face = plist_get (props, Qface);
 27600           if (NILP (face))
 27601             face = mode_line_string_face;
 27602           else
 27603             face = list2 (face, mode_line_string_face);
 27604           props = list2 (Qface, face);
 27605           if (copy_string)
 27606             lisp_string = Fcopy_sequence (lisp_string);
 27607         }
 27608       if (!NILP (props))
 27609         Fadd_text_properties (make_fixnum (0), make_fixnum (len),
 27610                               props, lisp_string);
 27611     }
 27612 
 27613   if (len > 0)
 27614     {
 27615       mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
 27616       n += len;
 27617     }
 27618 
 27619   if (field_width > len)
 27620     {
 27621       field_width -= len;
 27622       lisp_string = Fmake_string (make_fixnum (field_width), make_fixnum (' '),
 27623                                   Qnil);
 27624       if (!NILP (props))
 27625         Fadd_text_properties (make_fixnum (0), make_fixnum (field_width),
 27626                               props, lisp_string);
 27627       mode_line_string_list = Fcons (lisp_string, mode_line_string_list);
 27628       n += field_width;
 27629     }
 27630 
 27631   return n;
 27632 }
 27633 
 27634 
 27635 DEFUN ("format-mode-line", Fformat_mode_line, Sformat_mode_line,
 27636        1, 4, 0,
 27637        doc: /* Format a string out of a mode line format specification.
 27638 First arg FORMAT specifies the mode line format (see `mode-line-format'
 27639 for details) to use.
 27640 
 27641 By default, the format is evaluated for the currently selected window.
 27642 
 27643 Optional second arg FACE specifies the face property to put on all
 27644 characters for which no face is specified.  The value nil means the
 27645 default face.  The value t means whatever face the window's mode line
 27646 currently uses (either `mode-line' or `mode-line-inactive',
 27647 depending on whether the window is the selected window or not).
 27648 An integer value means the value string has no text
 27649 properties.
 27650 
 27651 Optional third and fourth args WINDOW and BUFFER specify the window
 27652 and buffer to use as the context for the formatting (defaults
 27653 are the selected window and the WINDOW's buffer).  */)
 27654      (Lisp_Object format, Lisp_Object face,
 27655       Lisp_Object window, Lisp_Object buffer)
 27656 {
 27657   struct it it;
 27658   int len;
 27659   struct window *w;
 27660   struct buffer *old_buffer = NULL;
 27661   int face_id;
 27662   bool no_props = FIXNUMP (face);
 27663   specpdl_ref count = SPECPDL_INDEX ();
 27664   Lisp_Object str;
 27665   int string_start = 0;
 27666 
 27667   w = decode_any_window (window);
 27668   XSETWINDOW (window, w);
 27669 
 27670   if (NILP (buffer))
 27671     buffer = w->contents;
 27672   CHECK_BUFFER (buffer);
 27673 
 27674   /* Make formatting the modeline a non-op when noninteractive, otherwise
 27675      there will be problems later caused by a partially initialized frame.  */
 27676   if (NILP (format) || noninteractive)
 27677     return empty_unibyte_string;
 27678 
 27679   if (no_props)
 27680     face = Qnil;
 27681 
 27682   face_id = (NILP (face) || EQ (face, Qdefault)) ? DEFAULT_FACE_ID
 27683     : EQ (face, Qt) ? (EQ (window, selected_window)
 27684                        ? MODE_LINE_ACTIVE_FACE_ID : MODE_LINE_INACTIVE_FACE_ID)
 27685     : EQ (face, Qmode_line_active) ? MODE_LINE_ACTIVE_FACE_ID
 27686     : EQ (face, Qmode_line_inactive) ? MODE_LINE_INACTIVE_FACE_ID
 27687     : EQ (face, Qheader_line) ? HEADER_LINE_FACE_ID
 27688     : EQ (face, Qtab_line) ? TAB_LINE_FACE_ID
 27689     : EQ (face, Qtab_bar) ? TAB_BAR_FACE_ID
 27690     : EQ (face, Qtool_bar) ? TOOL_BAR_FACE_ID
 27691     : DEFAULT_FACE_ID;
 27692 
 27693   old_buffer = current_buffer;
 27694 
 27695   /* Save things including mode_line_proptrans_alist,
 27696      and set that to nil so that we don't alter the outer value.  */
 27697   record_unwind_protect (unwind_format_mode_line,
 27698                          format_mode_line_unwind_data
 27699                            (XFRAME (WINDOW_FRAME (w)),
 27700                             old_buffer, selected_window, true));
 27701   mode_line_proptrans_alist = Qnil;
 27702 
 27703   Fselect_window (window, Qt);
 27704   set_buffer_internal_1 (XBUFFER (buffer));
 27705 
 27706   init_iterator (&it, w, -1, -1, NULL, face_id);
 27707 
 27708   if (no_props)
 27709     {
 27710       mode_line_target = MODE_LINE_NOPROP;
 27711       mode_line_string_face_prop = Qnil;
 27712       mode_line_string_list = Qnil;
 27713       string_start = MODE_LINE_NOPROP_LEN (0);
 27714     }
 27715   else
 27716     {
 27717       mode_line_target = MODE_LINE_STRING;
 27718       mode_line_string_list = Qnil;
 27719       mode_line_string_face = face;
 27720       mode_line_string_face_prop
 27721         = NILP (face) ? Qnil : list2 (Qface, face);
 27722     }
 27723 
 27724   push_kboard (FRAME_KBOARD (it.f));
 27725   display_mode_element (&it, 0, 0, 0, format, Qnil, false);
 27726   pop_kboard ();
 27727 
 27728   if (no_props)
 27729     {
 27730       len = MODE_LINE_NOPROP_LEN (string_start);
 27731       str = make_string (mode_line_noprop_buf + string_start, len);
 27732     }
 27733   else
 27734     {
 27735       mode_line_string_list = Fnreverse (mode_line_string_list);
 27736       str = Fmapconcat (Qidentity, mode_line_string_list,
 27737                         empty_unibyte_string);
 27738     }
 27739 
 27740   return unbind_to (count, str);
 27741 }
 27742 
 27743 /* Write a null-terminated, right justified decimal representation of
 27744    the positive integer D to BUF using a minimal field width WIDTH.  */
 27745 
 27746 static void
 27747 pint2str (register char *buf, register int width, register ptrdiff_t d)
 27748 {
 27749   register char *p = buf;
 27750 
 27751   if (d <= 0)
 27752     *p++ = '0';
 27753   else
 27754     {
 27755       while (d > 0)
 27756         {
 27757           *p++ = d % 10 + '0';
 27758           d /= 10;
 27759         }
 27760     }
 27761 
 27762   for (width -= (int) (p - buf); width > 0; --width)
 27763     *p++ = ' ';
 27764   *p-- = '\0';
 27765   while (p > buf)
 27766     {
 27767       d = *buf;
 27768       *buf++ = *p;
 27769       *p-- = d;
 27770     }
 27771 }
 27772 
 27773 /* Write a null-terminated, right justified decimal and "human
 27774    readable" representation of the nonnegative integer D to BUF using
 27775    a minimal field width WIDTH.  D should be smaller than 999.5e24. */
 27776 
 27777 static const char power_letter[] =
 27778   {
 27779     0,   /* no letter */
 27780     'k', /* kilo */
 27781     'M', /* mega */
 27782     'G', /* giga */
 27783     'T', /* tera */
 27784     'P', /* peta */
 27785     'E', /* exa */
 27786     'Z', /* zetta */
 27787     'Y', /* yotta */
 27788     'R', /* ronna */
 27789     'Q'  /* quetta */
 27790   };
 27791 
 27792 static void
 27793 pint2hrstr (char *buf, int width, ptrdiff_t d)
 27794 {
 27795   /* We aim to represent the nonnegative integer D as
 27796      QUOTIENT.TENTHS * 10 ^ (3 * EXPONENT). */
 27797   ptrdiff_t quotient = d;
 27798   int remainder = 0;
 27799   /* -1 means: do not use TENTHS. */
 27800   int tenths = -1;
 27801   int exponent = 0;
 27802 
 27803   /* Length of QUOTIENT.TENTHS as a string. */
 27804   int length;
 27805 
 27806   char * psuffix;
 27807   char * p;
 27808 
 27809   if (quotient >= 1000)
 27810     {
 27811       /* Scale to the appropriate EXPONENT. */
 27812       do
 27813         {
 27814           remainder = quotient % 1000;
 27815           quotient /= 1000;
 27816           exponent++;
 27817         }
 27818       while (quotient >= 1000);
 27819 
 27820       /* Round to nearest and decide whether to use TENTHS or not. */
 27821       if (quotient <= 9)
 27822         {
 27823           tenths = remainder / 100;
 27824           if (remainder % 100 >= 50)
 27825             {
 27826               if (tenths < 9)
 27827                 tenths++;
 27828               else
 27829                 {
 27830                   quotient++;
 27831                   if (quotient == 10)
 27832                     tenths = -1;
 27833                   else
 27834                     tenths = 0;
 27835                 }
 27836             }
 27837         }
 27838       else
 27839         if (remainder >= 500)
 27840           {
 27841             if (quotient < 999)
 27842               quotient++;
 27843             else
 27844               {
 27845                 quotient = 1;
 27846                 exponent++;
 27847                 tenths = 0;
 27848               }
 27849           }
 27850     }
 27851 
 27852   /* Calculate the LENGTH of QUOTIENT.TENTHS as a string. */
 27853   if (tenths == -1 && quotient <= 99)
 27854     if (quotient <= 9)
 27855       length = 1;
 27856     else
 27857       length = 2;
 27858   else
 27859     length = 3;
 27860   p = psuffix = buf + max (width, length);
 27861 
 27862   /* Print EXPONENT. */
 27863   *psuffix++ = power_letter[exponent];
 27864   *psuffix = '\0';
 27865 
 27866   /* Print TENTHS. */
 27867   if (tenths >= 0)
 27868     {
 27869       *--p = '0' + tenths;
 27870       *--p = '.';
 27871     }
 27872 
 27873   /* Print QUOTIENT. */
 27874   do
 27875     {
 27876       int digit = quotient % 10;
 27877       *--p =  '0' + digit;
 27878     }
 27879   while ((quotient /= 10) != 0);
 27880 
 27881   /* Print leading spaces. */
 27882   while (buf < p)
 27883     *--p = ' ';
 27884 }
 27885 
 27886 /* Set a mnemonic character for coding_system (Lisp symbol) in BUF.
 27887    If EOL_FLAG, set also a mnemonic character for end-of-line
 27888    type of CODING_SYSTEM.  Return updated pointer into BUF.  */
 27889 
 27890 static unsigned char invalid_eol_type[] = "(*invalid*)";
 27891 
 27892 static char *
 27893 decode_mode_spec_coding (Lisp_Object coding_system, char *buf, bool eol_flag)
 27894 {
 27895   Lisp_Object val;
 27896   bool multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
 27897   const unsigned char *eol_str;
 27898   int eol_str_len;
 27899   /* The EOL conversion we are using.  */
 27900   Lisp_Object eoltype;
 27901 
 27902   val = CODING_SYSTEM_SPEC (coding_system);
 27903   eoltype = Qnil;
 27904 
 27905   if (!VECTORP (val))           /* Not yet decided.  */
 27906     {
 27907       *buf++ = multibyte ? '-' : ' ';
 27908       if (eol_flag)
 27909         eoltype = eol_mnemonic_undecided;
 27910       /* Don't mention EOL conversion if it isn't decided.  */
 27911     }
 27912   else
 27913     {
 27914       Lisp_Object attrs;
 27915       Lisp_Object eolvalue;
 27916 
 27917       attrs = AREF (val, 0);
 27918       eolvalue = AREF (val, 2);
 27919 
 27920       if (multibyte)
 27921         buf += CHAR_STRING (XFIXNAT (CODING_ATTR_MNEMONIC (attrs)),
 27922                             (unsigned char *) buf);
 27923       else
 27924         *buf++ = ' ';
 27925 
 27926       if (eol_flag)
 27927         {
 27928           /* The EOL conversion that is normal on this system.  */
 27929 
 27930           if (NILP (eolvalue))  /* Not yet decided.  */
 27931             eoltype = eol_mnemonic_undecided;
 27932           else if (VECTORP (eolvalue)) /* Not yet decided.  */
 27933             eoltype = eol_mnemonic_undecided;
 27934           else                  /* eolvalue is Qunix, Qdos, or Qmac.  */
 27935             eoltype = (EQ (eolvalue, Qunix)
 27936                        ? eol_mnemonic_unix
 27937                        : EQ (eolvalue, Qdos)
 27938                        ? eol_mnemonic_dos : eol_mnemonic_mac);
 27939         }
 27940     }
 27941 
 27942   if (eol_flag)
 27943     {
 27944       /* Mention the EOL conversion if it is not the usual one.  */
 27945       if (STRINGP (eoltype))
 27946         {
 27947           eol_str = SDATA (eoltype);
 27948           eol_str_len = SBYTES (eoltype);
 27949         }
 27950       else if (CHARACTERP (eoltype))
 27951         {
 27952           int c = XFIXNAT (eoltype);
 27953           return buf + CHAR_STRING (c, (unsigned char *) buf);
 27954         }
 27955       else
 27956         {
 27957           eol_str = invalid_eol_type;
 27958           eol_str_len = sizeof (invalid_eol_type) - 1;
 27959         }
 27960       memcpy (buf, eol_str, eol_str_len);
 27961       buf += eol_str_len;
 27962     }
 27963 
 27964   return buf;
 27965 }
 27966 
 27967 /* Return the approximate percentage N is of D (rounding upward), or 99,
 27968    whichever is less.  Assume 0 < D and 0 <= N <= D * INT_MAX / 100.  */
 27969 
 27970 static int
 27971 percent99 (ptrdiff_t n, ptrdiff_t d)
 27972 {
 27973   int percent = (d - 1 + 100.0 * n) / d;
 27974   return min (percent, 99);
 27975 }
 27976 
 27977 /* Return a string for the output of a mode line %-spec for window W,
 27978    generated by character C.  FIELD_WIDTH > 0 means pad the string
 27979    returned with spaces to that value.  Set *STRING to be a Lisp
 27980    string if the resulting string is taken from that Lisp string;
 27981    otherwise, set *STRING to Qnil.
 27982 
 27983    Note we operate on the current buffer for most purposes.  */
 27984 
 27985 static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
 27986 
 27987 static const char *
 27988 decode_mode_spec (struct window *w, register int c, int field_width,
 27989                   Lisp_Object *string)
 27990 {
 27991   Lisp_Object obj;
 27992   struct frame *f = XFRAME (WINDOW_FRAME (w));
 27993   char *decode_mode_spec_buf = f->decode_mode_spec_buffer;
 27994   /* We are going to use f->decode_mode_spec_buffer as the buffer to
 27995      produce strings from numerical values, so limit preposterously
 27996      large values of FIELD_WIDTH to avoid overrunning the buffer's
 27997      end.  The size of the buffer is enough for FRAME_MESSAGE_BUF_SIZE
 27998      bytes plus the terminating null.  */
 27999   int width = min (field_width, FRAME_MESSAGE_BUF_SIZE (f));
 28000   struct buffer *b = current_buffer;
 28001 
 28002   obj = Qnil;
 28003   *string = Qnil;
 28004 
 28005   switch (c)
 28006     {
 28007     case '*':
 28008       if (!NILP (BVAR (b, read_only)))
 28009         return "%";
 28010       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
 28011         return "*";
 28012       return "-";
 28013 
 28014     case '+':
 28015       /* This differs from %* only for a modified read-only buffer.  */
 28016       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
 28017         return "*";
 28018       if (!NILP (BVAR (b, read_only)))
 28019         return "%";
 28020       return "-";
 28021 
 28022     case '&':
 28023       /* This differs from %* in ignoring read-only-ness.  */
 28024       if (BUF_MODIFF (b) > BUF_SAVE_MODIFF (b))
 28025         return "*";
 28026       return "-";
 28027 
 28028     case '%':
 28029       return "%";
 28030 
 28031     case '[':
 28032       {
 28033         int i;
 28034         char *p;
 28035 
 28036         if (command_loop_level > 5)
 28037           return "[[[... ";
 28038         p = decode_mode_spec_buf;
 28039         for (i = 0; i < command_loop_level; i++)
 28040           *p++ = '[';
 28041         *p = 0;
 28042         return decode_mode_spec_buf;
 28043       }
 28044 
 28045     case ']':
 28046       {
 28047         int i;
 28048         char *p;
 28049 
 28050         if (command_loop_level > 5)
 28051           return " ...]]]";
 28052         p = decode_mode_spec_buf;
 28053         for (i = 0; i < command_loop_level; i++)
 28054           *p++ = ']';
 28055         *p = 0;
 28056         return decode_mode_spec_buf;
 28057       }
 28058 
 28059     case '-':
 28060       {
 28061         register int i;
 28062 
 28063         /* Let lots_of_dashes be a string of infinite length.  */
 28064         if (mode_line_target == MODE_LINE_NOPROP
 28065             || mode_line_target == MODE_LINE_STRING)
 28066           return "--";
 28067         if (field_width <= 0
 28068             || field_width > sizeof (lots_of_dashes))
 28069           {
 28070             for (i = 0; i < FRAME_MESSAGE_BUF_SIZE (f) - 1; ++i)
 28071               decode_mode_spec_buf[i] = '-';
 28072             decode_mode_spec_buf[i] = '\0';
 28073             return decode_mode_spec_buf;
 28074           }
 28075         else
 28076           return lots_of_dashes;
 28077       }
 28078 
 28079     case 'b':
 28080       obj = BVAR (b, name);
 28081       break;
 28082 
 28083     case 'c':
 28084     case 'C':
 28085       /* %c, %C, and %l are ignored in `frame-title-format'.
 28086          (In redisplay_internal, the frame title is drawn _before_ the
 28087          windows are updated, so the stuff which depends on actual
 28088          window contents (such as %l) may fail to render properly, or
 28089          even crash emacs.)  */
 28090       if (mode_line_target == MODE_LINE_TITLE)
 28091         return "";
 28092       else
 28093         {
 28094           ptrdiff_t col = current_column ();
 28095           int disp_col = (c == 'C') ? col + 1 : col;
 28096           w->column_number_displayed = col;
 28097           pint2str (decode_mode_spec_buf, width, disp_col);
 28098           return decode_mode_spec_buf;
 28099         }
 28100 
 28101     case 'e':
 28102 #if !defined SYSTEM_MALLOC && !defined HYBRID_MALLOC
 28103       {
 28104         if (NILP (Vmemory_full))
 28105           return "";
 28106         else
 28107           return "!MEM FULL! ";
 28108       }
 28109 #else
 28110       return "";
 28111 #endif
 28112 
 28113     case 'F':
 28114       /* %F displays the frame name.  */
 28115       if (!NILP (f->title))
 28116         return SSDATA (f->title);
 28117       if (f->explicit_name || ! FRAME_WINDOW_P (f))
 28118         return SSDATA (f->name);
 28119       return "Emacs";
 28120 
 28121     case 'f':
 28122       obj = BVAR (b, filename);
 28123       break;
 28124 
 28125     case 'i':
 28126       {
 28127         ptrdiff_t size = ZV - BEGV;
 28128         pint2str (decode_mode_spec_buf, width, size);
 28129         return decode_mode_spec_buf;
 28130       }
 28131 
 28132     case 'I':
 28133       {
 28134         ptrdiff_t size = ZV - BEGV;
 28135         pint2hrstr (decode_mode_spec_buf, width, size);
 28136         return decode_mode_spec_buf;
 28137       }
 28138 
 28139     case 'l':
 28140       {
 28141         ptrdiff_t startpos, startpos_byte, line, linepos, linepos_byte;
 28142         ptrdiff_t topline, nlines, height;
 28143         ptrdiff_t junk;
 28144 
 28145         /* %c, %C, and %l are ignored in `frame-title-format'.  */
 28146         if (mode_line_target == MODE_LINE_TITLE)
 28147           return "";
 28148 
 28149         startpos = marker_position (w->start);
 28150         startpos_byte = marker_byte_position (w->start);
 28151         height = WINDOW_TOTAL_LINES (w);
 28152         /* We cannot cope with w->start being outside of the
 28153            accessible portion of the buffer; in particular,
 28154            display_count_lines call below might infloop if called with
 28155            startpos_byte outside of the [BEGV_BYTE..ZV_BYTE] region.
 28156            Such w->start means we were called in some "creative" way
 28157            when the buffer's restriction was changed, but the window
 28158            wasn't yet redisplayed after that.  If that happens, we
 28159            need to determine a new base line.  */
 28160         if (!(BUF_BEGV_BYTE (b) <= startpos_byte
 28161               && startpos_byte <= BUF_ZV_BYTE (b)))
 28162           {
 28163             startpos = BUF_BEGV (b);
 28164             startpos_byte = BUF_BEGV_BYTE (b);
 28165             w->base_line_pos = 0;
 28166             w->base_line_number = 0;
 28167           }
 28168 
 28169         /* If we decided that this buffer isn't suitable for line numbers,
 28170            don't forget that too fast.  */
 28171         if (w->base_line_pos == -1)
 28172           goto no_value;
 28173 
 28174         /* If the buffer is very big, don't waste time.  */
 28175         if (FIXNUMP (Vline_number_display_limit)
 28176             && BUF_ZV (b) - BUF_BEGV (b) > XFIXNUM (Vline_number_display_limit))
 28177           {
 28178             w->base_line_pos = 0;
 28179             w->base_line_number = 0;
 28180             goto no_value;
 28181           }
 28182 
 28183         if (w->base_line_number > 0
 28184             && w->base_line_pos > 0
 28185             && w->base_line_pos <= startpos)
 28186           {
 28187             line = w->base_line_number;
 28188             linepos = w->base_line_pos;
 28189             linepos_byte = buf_charpos_to_bytepos (b, linepos);
 28190           }
 28191         else
 28192           {
 28193             line = 1;
 28194             linepos = BUF_BEGV (b);
 28195             linepos_byte = BUF_BEGV_BYTE (b);
 28196           }
 28197 
 28198         /* Count lines from base line to window start position.  */
 28199         nlines = display_count_lines (linepos_byte,
 28200                                       startpos_byte,
 28201                                       startpos, &junk);
 28202 
 28203         topline = nlines + line;
 28204 
 28205         /* Determine a new base line, if the old one is too close
 28206            or too far away, or if we did not have one.
 28207            "Too close" means it's plausible a scroll-down would
 28208            go back past it.  */
 28209         if (startpos == BUF_BEGV (b))
 28210           {
 28211             w->base_line_number = topline;
 28212             w->base_line_pos = BUF_BEGV (b);
 28213           }
 28214         else if (nlines < height + 25 || nlines > height * 3 + 50
 28215                  || linepos == BUF_BEGV (b))
 28216           {
 28217             ptrdiff_t limit = BUF_BEGV (b);
 28218             ptrdiff_t limit_byte = BUF_BEGV_BYTE (b);
 28219             ptrdiff_t position;
 28220             ptrdiff_t distance
 28221               = (line_number_display_limit_width < 0 ? 0
 28222                  : ckd_mul (&distance, line_number_display_limit_width,
 28223                             height * 2 + 30)
 28224                  ? PTRDIFF_MAX : distance);
 28225 
 28226             if (startpos - distance > limit)
 28227               {
 28228                 limit = startpos - distance;
 28229                 limit_byte = CHAR_TO_BYTE (limit);
 28230               }
 28231 
 28232             nlines = display_count_lines (startpos_byte,
 28233                                           limit_byte,
 28234                                           - (height * 2 + 30),
 28235                                           &position);
 28236             /* If we couldn't find the lines we wanted within
 28237                line_number_display_limit_width chars per line,
 28238                give up on line numbers for this window.  */
 28239             if (position == limit_byte && limit == startpos - distance)
 28240               {
 28241                 w->base_line_pos = -1;
 28242                 w->base_line_number = 0;
 28243                 goto no_value;
 28244               }
 28245 
 28246             w->base_line_number = topline - nlines;
 28247             w->base_line_pos = BYTE_TO_CHAR (position);
 28248           }
 28249 
 28250         /* Now count lines from the start pos to point.  */
 28251         nlines = display_count_lines (startpos_byte,
 28252                                       PT_BYTE, PT, &junk);
 28253 
 28254         /* Record that we did display the line number.  */
 28255         line_number_displayed = true;
 28256 
 28257         /* Make the string to show.  */
 28258         pint2str (decode_mode_spec_buf, width, topline + nlines);
 28259         return decode_mode_spec_buf;
 28260     no_value:
 28261         {
 28262           char *p = decode_mode_spec_buf;
 28263           int pad = width - 2;
 28264           while (pad-- > 0)
 28265             *p++ = ' ';
 28266           *p++ = '?';
 28267           *p++ = '?';
 28268           *p = '\0';
 28269           return decode_mode_spec_buf;
 28270         }
 28271       }
 28272       break;
 28273 
 28274     case 'm':
 28275       obj = BVAR (b, mode_name);
 28276       break;
 28277 
 28278     case 'n':
 28279       if (BUF_BEGV (b) > BUF_BEG (b) || BUF_ZV (b) < BUF_Z (b))
 28280         return " Narrow";
 28281       break;
 28282 
 28283       /* Display the "degree of travel" of the window through the buffer.  */
 28284     case 'o':
 28285       {
 28286         ptrdiff_t toppos = marker_position (w->start);
 28287         ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
 28288         ptrdiff_t begv = BUF_BEGV (b);
 28289         ptrdiff_t zv = BUF_ZV (b);
 28290 
 28291         if (zv <= botpos)
 28292           return toppos <= begv ? "All" : "Bottom";
 28293         else if (toppos <= begv)
 28294           return "Top";
 28295         else
 28296           {
 28297           sprintf (decode_mode_spec_buf, "%2d%%",
 28298                    percent99 (toppos - begv, (toppos - begv) + (zv - botpos)));
 28299           return decode_mode_spec_buf;
 28300           }
 28301       }
 28302 
 28303       /* Display percentage of buffer above the top of the screen.  */
 28304     case 'p':
 28305       {
 28306         ptrdiff_t pos = marker_position (w->start);
 28307         ptrdiff_t begv = BUF_BEGV (b);
 28308         ptrdiff_t zv = BUF_ZV (b);
 28309 
 28310         if (w->window_end_pos <= BUF_Z (b) - zv)
 28311           return pos <= begv ? "All" : "Bottom";
 28312         else if (pos <= begv)
 28313           return "Top";
 28314         else
 28315           {
 28316             sprintf (decode_mode_spec_buf, "%2d%%",
 28317                      percent99 (pos - begv, zv - begv));
 28318             return decode_mode_spec_buf;
 28319           }
 28320       }
 28321 
 28322       /* Display percentage of size above the bottom of the screen.  */
 28323     case 'P':
 28324       {
 28325         ptrdiff_t toppos = marker_position (w->start);
 28326         ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
 28327         ptrdiff_t begv = BUF_BEGV (b);
 28328         ptrdiff_t zv = BUF_ZV (b);
 28329 
 28330         if (zv <= botpos)
 28331           return toppos <= begv ? "All" : "Bottom";
 28332         else
 28333           {
 28334             sprintf (decode_mode_spec_buf,
 28335                      &"Top%2d%%"[begv < toppos ? sizeof "Top" - 1 : 0],
 28336                      percent99 (botpos - begv, zv - begv));
 28337             return decode_mode_spec_buf;
 28338           }
 28339       }
 28340 
 28341       /* Display percentage offsets of top and bottom of the window,
 28342          using "All" (but not "Top" or "Bottom") where appropriate.  */
 28343     case 'q':
 28344       {
 28345         ptrdiff_t toppos = marker_position (w->start);
 28346         ptrdiff_t botpos = BUF_Z (b) - w->window_end_pos;
 28347         ptrdiff_t begv = BUF_BEGV (b);
 28348         ptrdiff_t zv = BUF_ZV (b);
 28349         int top_perc, bot_perc;
 28350 
 28351         if ((toppos <= begv) && (zv <= botpos))
 28352           return "All   ";
 28353 
 28354         top_perc = toppos <= begv ? 0 : percent99 (toppos - begv, zv - begv);
 28355         bot_perc = zv <= botpos ? 100 : percent99 (botpos - begv, zv - begv);
 28356 
 28357         if (top_perc == bot_perc)
 28358           sprintf (decode_mode_spec_buf, "%d%%", top_perc);
 28359         else
 28360           sprintf (decode_mode_spec_buf, "%d-%d%%", top_perc, bot_perc);
 28361 
 28362         return decode_mode_spec_buf;
 28363       }
 28364 
 28365     case 's':
 28366       /* status of process */
 28367       obj = Fget_buffer_process (Fcurrent_buffer ());
 28368       if (NILP (obj))
 28369         return "no process";
 28370 #ifndef MSDOS
 28371       obj = Fsymbol_name (Fprocess_status (obj));
 28372 #endif
 28373       break;
 28374 
 28375     case '@':
 28376       {
 28377         specpdl_ref count = inhibit_garbage_collection ();
 28378         Lisp_Object curdir = BVAR (current_buffer, directory);
 28379         Lisp_Object val = Qnil;
 28380 
 28381         if (STRINGP (curdir))
 28382           val = safe_call1 (intern ("file-remote-p"), curdir);
 28383 
 28384         val = unbind_to (count, val);
 28385 
 28386         if (NILP (val))
 28387           return "-";
 28388         else
 28389           return "@";
 28390       }
 28391 
 28392     case 'z':
 28393       /* coding-system (not including end-of-line format) */
 28394     case 'Z':
 28395       /* coding-system (including end-of-line type) */
 28396       {
 28397         bool eol_flag = (c == 'Z');
 28398         char *p = decode_mode_spec_buf;
 28399 
 28400         if (! FRAME_WINDOW_P (f))
 28401           {
 28402             /* No need to mention EOL here--the terminal never needs
 28403                to do EOL conversion.  */
 28404             p = decode_mode_spec_coding (CODING_ID_NAME
 28405                                          (FRAME_KEYBOARD_CODING (f)->id),
 28406                                          p, false);
 28407             p = decode_mode_spec_coding (CODING_ID_NAME
 28408                                          (FRAME_TERMINAL_CODING (f)->id),
 28409                                          p, false);
 28410           }
 28411         p = decode_mode_spec_coding (BVAR (b, buffer_file_coding_system),
 28412                                      p, eol_flag);
 28413 
 28414 #if false /* This proves to be annoying; I think we can do without. -- rms.  */
 28415 #ifdef subprocesses
 28416         obj = Fget_buffer_process (Fcurrent_buffer ());
 28417         if (PROCESSP (obj))
 28418           {
 28419             p = decode_mode_spec_coding
 28420               (XPROCESS (obj)->decode_coding_system, p, eol_flag);
 28421             p = decode_mode_spec_coding
 28422               (XPROCESS (obj)->encode_coding_system, p, eol_flag);
 28423           }
 28424 #endif /* subprocesses */
 28425 #endif /* false */
 28426         *p = 0;
 28427         return decode_mode_spec_buf;
 28428       }
 28429     }
 28430 
 28431   if (STRINGP (obj))
 28432     {
 28433       *string = obj;
 28434       return SSDATA (obj);
 28435     }
 28436   else
 28437     return "";
 28438 }
 28439 
 28440 /* Return the number of lines between start_byte and end_byte in the
 28441    current buffer. */
 28442 
 28443 ptrdiff_t
 28444 count_lines (ptrdiff_t start_byte, ptrdiff_t end_byte)
 28445 {
 28446   ptrdiff_t ignored;
 28447   return display_count_lines (start_byte, end_byte, ZV, &ignored);
 28448 }
 28449 
 28450 /* Count up to COUNT lines starting from START_BYTE.  COUNT negative
 28451    means count lines back from START_BYTE.  But don't go beyond
 28452    LIMIT_BYTE.  Return the number of lines thus found (always
 28453    nonnegative).
 28454 
 28455    Set *BYTE_POS_PTR to the byte position where we stopped.  This is
 28456    either the position COUNT lines after/before START_BYTE, if we
 28457    found COUNT lines, or LIMIT_BYTE if we hit the limit before finding
 28458    COUNT lines.  */
 28459 
 28460 static ptrdiff_t
 28461 display_count_lines (ptrdiff_t start_byte,
 28462                      ptrdiff_t limit_byte, ptrdiff_t count,
 28463                      ptrdiff_t *byte_pos_ptr)
 28464 {
 28465   register unsigned char *cursor;
 28466   unsigned char *base;
 28467 
 28468   register ptrdiff_t ceiling;
 28469   register unsigned char *ceiling_addr;
 28470   ptrdiff_t orig_count = count;
 28471 
 28472   /* If we are not in selective display mode,
 28473      check only for newlines.  */
 28474   bool selective_display
 28475     = (!NILP (BVAR (current_buffer, selective_display))
 28476        && !FIXNUMP (BVAR (current_buffer, selective_display)));
 28477 
 28478   if (count > 0)
 28479     {
 28480       while (start_byte < limit_byte)
 28481         {
 28482           ceiling =  BUFFER_CEILING_OF (start_byte);
 28483           ceiling = min (limit_byte - 1, ceiling);
 28484           ceiling_addr = BYTE_POS_ADDR (ceiling) + 1;
 28485           base = (cursor = BYTE_POS_ADDR (start_byte));
 28486 
 28487           do
 28488             {
 28489               if (selective_display)
 28490                 {
 28491                   while (*cursor != '\n' && *cursor != 015
 28492                          && ++cursor != ceiling_addr)
 28493                     continue;
 28494                   if (cursor == ceiling_addr)
 28495                     break;
 28496                 }
 28497               else
 28498                 {
 28499                   cursor = memchr (cursor, '\n', ceiling_addr - cursor);
 28500                   if (! cursor)
 28501                     break;
 28502                 }
 28503 
 28504               cursor++;
 28505 
 28506               if (--count == 0)
 28507                 {
 28508                   start_byte += cursor - base;
 28509                   *byte_pos_ptr = start_byte;
 28510                   return orig_count;
 28511                 }
 28512             }
 28513           while (cursor < ceiling_addr);
 28514 
 28515           start_byte += ceiling_addr - base;
 28516         }
 28517     }
 28518   else
 28519     {
 28520       while (start_byte > limit_byte)
 28521         {
 28522           ceiling = BUFFER_FLOOR_OF (start_byte - 1);
 28523           ceiling = max (limit_byte, ceiling);
 28524           ceiling_addr = BYTE_POS_ADDR (ceiling);
 28525           base = (cursor = BYTE_POS_ADDR (start_byte - 1) + 1);
 28526           while (true)
 28527             {
 28528               if (selective_display)
 28529                 {
 28530                   while (--cursor >= ceiling_addr
 28531                          && *cursor != '\n' && *cursor != 015)
 28532                     continue;
 28533                   if (cursor < ceiling_addr)
 28534                     break;
 28535                 }
 28536               else
 28537                 {
 28538                   cursor = memrchr (ceiling_addr, '\n', cursor - ceiling_addr);
 28539                   if (! cursor)
 28540                     break;
 28541                 }
 28542 
 28543               if (++count == 0)
 28544                 {
 28545                   start_byte += cursor - base + 1;
 28546                   *byte_pos_ptr = start_byte;
 28547                   /* When scanning backwards, we should
 28548                      not count the newline posterior to which we stop.  */
 28549                   return - orig_count - 1;
 28550                 }
 28551             }
 28552           start_byte += ceiling_addr - base;
 28553         }
 28554     }
 28555 
 28556   *byte_pos_ptr = limit_byte;
 28557 
 28558   if (count < 0)
 28559     return - orig_count + count;
 28560   return orig_count - count;
 28561 
 28562 }
 28563 
 28564 
 28565 
 28566 /***********************************************************************
 28567                          Displaying strings
 28568  ***********************************************************************/
 28569 
 28570 /* Display a NUL-terminated string, starting with index START.
 28571 
 28572    If STRING is non-null, display that C string.  Otherwise, the Lisp
 28573    string LISP_STRING is displayed.  There's a case that STRING is
 28574    non-null and LISP_STRING is not nil.  It means STRING is a string
 28575    data of LISP_STRING.  In that case, we display LISP_STRING while
 28576    ignoring its text properties.
 28577 
 28578    If FACE_STRING is not nil, FACE_STRING_POS is a position in
 28579    FACE_STRING.  Display STRING or LISP_STRING with the face at
 28580    FACE_STRING_POS in FACE_STRING:
 28581 
 28582    Display the string in the environment given by IT, but use the
 28583    standard display table, temporarily.
 28584 
 28585    FIELD_WIDTH is the minimum number of output glyphs to produce.
 28586    If STRING has fewer characters than FIELD_WIDTH, pad to the right
 28587    with spaces.  If STRING has more characters, more than FIELD_WIDTH
 28588    glyphs will be produced.  FIELD_WIDTH <= 0 means don't pad.
 28589 
 28590    PRECISION is the maximum number of characters to output from
 28591    STRING.  PRECISION < 0  means don't truncate the string.
 28592 
 28593    This is roughly equivalent to printf format specifiers:
 28594 
 28595    FIELD_WIDTH  PRECISION       PRINTF
 28596    ----------------------------------------
 28597    -1           -1              %s
 28598    -1           10              %.10s
 28599    10           -1              %10s
 28600    20           10              %20.10s
 28601 
 28602    MULTIBYTE zero means do not display multibyte chars, > 0 means do
 28603    display them, and < 0 means obey the current buffer's value of
 28604    enable_multibyte_characters.
 28605 
 28606    Value is the number of columns displayed.  */
 28607 
 28608 static int
 28609 display_string (const char *string, Lisp_Object lisp_string, Lisp_Object face_string,
 28610                 ptrdiff_t face_string_pos, ptrdiff_t start, struct it *it,
 28611                 int field_width, int precision, int max_x, int multibyte)
 28612 {
 28613   int hpos_at_start = it->hpos;
 28614   int saved_face_id = it->face_id;
 28615   struct glyph_row *row = it->glyph_row;
 28616   ptrdiff_t it_charpos;
 28617 
 28618   /* Initialize the iterator IT for iteration over STRING beginning
 28619      with index START.  */
 28620   reseat_to_string (it, NILP (lisp_string) ? string : NULL, lisp_string,
 28621                     start, precision, field_width, multibyte);
 28622 
 28623   if (string && STRINGP (lisp_string))
 28624     /* LISP_STRING is the one returned by decode_mode_spec.  We should
 28625        ignore its text properties.  */
 28626     it->stop_charpos = it->end_charpos;
 28627 
 28628   /* If displaying STRING, set up the face of the iterator from
 28629      FACE_STRING, if that's given.  */
 28630   if (STRINGP (face_string))
 28631     {
 28632       ptrdiff_t endptr;
 28633       struct face *face;
 28634 
 28635       it->face_id
 28636         = face_at_string_position (it->w, face_string, face_string_pos,
 28637                                    0, &endptr, it->base_face_id, false, 0);
 28638       face = FACE_FROM_ID (it->f, it->face_id);
 28639       it->face_box_p = face->box != FACE_NO_BOX;
 28640 
 28641       /* If we have a display spec, but there's no Lisp string being
 28642          displayed, then check whether we've got one from the
 28643          :propertize being passed in and use that.  */
 28644       if (NILP (lisp_string))
 28645         {
 28646           Lisp_Object display = Fget_text_property (make_fixnum (0), Qdisplay,
 28647                                                     face_string);
 28648           if (!NILP (display))
 28649             {
 28650               Lisp_Object min_width = plist_get (display, Qmin_width);
 28651               if (!NILP (min_width))
 28652                 display_min_width (it, 0, face_string, min_width);
 28653             }
 28654         }
 28655     }
 28656 
 28657   /* Set max_x to the maximum allowed X position.  Don't let it go
 28658      beyond the right edge of the window.  */
 28659   if (max_x <= 0)
 28660     max_x = it->last_visible_x;
 28661   else
 28662     max_x = min (max_x, it->last_visible_x);
 28663 
 28664   /* Skip over display elements that are not visible because IT->w is
 28665      hscrolled.  */
 28666   if (it->current_x < it->first_visible_x)
 28667     move_it_in_display_line_to (it, 100000, it->first_visible_x,
 28668                                 MOVE_TO_POS | MOVE_TO_X);
 28669 
 28670   row->ascent = it->max_ascent;
 28671   row->height = it->max_ascent + it->max_descent;
 28672   row->phys_ascent = it->max_phys_ascent;
 28673   row->phys_height = it->max_phys_ascent + it->max_phys_descent;
 28674   row->extra_line_spacing = it->max_extra_line_spacing;
 28675 
 28676   if (STRINGP (it->string))
 28677     it_charpos = IT_STRING_CHARPOS (*it);
 28678   else
 28679     it_charpos = IT_CHARPOS (*it);
 28680 
 28681   /* This condition is for the case that we are called with current_x
 28682      past last_visible_x.  */
 28683   while (it->current_x < max_x)
 28684     {
 28685       int x_before, x, n_glyphs_before, i, nglyphs;
 28686 
 28687       /* Get the next display element.  */
 28688       if (!get_next_display_element (it))
 28689         break;
 28690 
 28691       /* Produce glyphs.  */
 28692       x_before = it->current_x;
 28693       n_glyphs_before = row->used[TEXT_AREA];
 28694       PRODUCE_GLYPHS (it);
 28695 
 28696       nglyphs = row->used[TEXT_AREA] - n_glyphs_before;
 28697       i = 0;
 28698       x = x_before;
 28699       while (i < nglyphs)
 28700         {
 28701           struct glyph *glyph = row->glyphs[TEXT_AREA] + n_glyphs_before + i;
 28702 
 28703           if (it->line_wrap != TRUNCATE
 28704               && x + glyph->pixel_width > max_x)
 28705             {
 28706               /* End of continued line or max_x reached.  */
 28707               if (CHAR_GLYPH_PADDING_P (*glyph))
 28708                 {
 28709                   /* A wide character is unbreakable.  */
 28710                   if (row->reversed_p)
 28711                     unproduce_glyphs (it, row->used[TEXT_AREA]
 28712                                       - n_glyphs_before);
 28713                   row->used[TEXT_AREA] = n_glyphs_before;
 28714                   it->current_x = x_before;
 28715                 }
 28716               else
 28717                 {
 28718                   if (row->reversed_p)
 28719                     unproduce_glyphs (it, row->used[TEXT_AREA]
 28720                                       - (n_glyphs_before + i));
 28721                   row->used[TEXT_AREA] = n_glyphs_before + i;
 28722                   it->current_x = x;
 28723                 }
 28724               break;
 28725             }
 28726           else if (x + glyph->pixel_width >= it->first_visible_x)
 28727             {
 28728               /* Glyph is at least partially visible.  */
 28729               ++it->hpos;
 28730               if (x < it->first_visible_x)
 28731                 row->x = x - it->first_visible_x;
 28732             }
 28733           else
 28734             {
 28735               /* Glyph is off the left margin of the display area.
 28736                  Should not happen.  */
 28737               emacs_abort ();
 28738             }
 28739 
 28740           row->ascent = max (row->ascent, it->max_ascent);
 28741           row->height = max (row->height, it->max_ascent + it->max_descent);
 28742           row->phys_ascent = max (row->phys_ascent, it->max_phys_ascent);
 28743           row->phys_height = max (row->phys_height,
 28744                                   it->max_phys_ascent + it->max_phys_descent);
 28745           row->extra_line_spacing = max (row->extra_line_spacing,
 28746                                          it->max_extra_line_spacing);
 28747           x += glyph->pixel_width;
 28748           ++i;
 28749         }
 28750 
 28751       /* Stop if max_x reached.  */
 28752       if (i < nglyphs)
 28753         break;
 28754 
 28755       /* Stop at line ends.  */
 28756       if (ITERATOR_AT_END_OF_LINE_P (it))
 28757         {
 28758           it->continuation_lines_width = 0;
 28759           break;
 28760         }
 28761 
 28762       set_iterator_to_next (it, true);
 28763       if (STRINGP (it->string))
 28764         it_charpos = IT_STRING_CHARPOS (*it);
 28765       else
 28766         it_charpos = IT_CHARPOS (*it);
 28767 
 28768       /* Stop if truncating at the right edge.  */
 28769       if (it->line_wrap == TRUNCATE
 28770           && it->current_x >= it->last_visible_x)
 28771         {
 28772           /* Add truncation mark, but don't do it if the line is
 28773              truncated at a padding space.  */
 28774           /* Need to do the below for the last string character as
 28775              well, since it could be a double-width character, in
 28776              which case the previous character ends before
 28777              last_visible_x.  Thus, comparison with <=, not <.  */
 28778           if (it_charpos <= it->string_nchars)
 28779             {
 28780               if (!FRAME_WINDOW_P (it->f))
 28781                 {
 28782                   int ii, n;
 28783 
 28784                   if (it->current_x > it->last_visible_x)
 28785                     {
 28786                       /* This flag is true if we are displaying mode
 28787                          line, false for header-line or tab-line.  */
 28788                       bool mode_line_p = false;
 28789 
 28790                       /* ROW->mode_line_p is true if we display mode
 28791                          line or header-line or tab-line.  */
 28792                       if (row->mode_line_p)
 28793                         {
 28794                           struct window *w = it->w;
 28795                           if (row == MATRIX_MODE_LINE_ROW (w->desired_matrix))
 28796                             mode_line_p = true;
 28797                         }
 28798                       if (!row->reversed_p)
 28799                         {
 28800                           for (ii = row->used[TEXT_AREA] - 1; ii > 0; --ii)
 28801                             if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
 28802                               break;
 28803                         }
 28804                       else
 28805                         {
 28806                           for (ii = 0; ii < row->used[TEXT_AREA]; ii++)
 28807                             if (!CHAR_GLYPH_PADDING_P (row->glyphs[TEXT_AREA][ii]))
 28808                               break;
 28809                           unproduce_glyphs (it, ii + 1);
 28810                           ii = row->used[TEXT_AREA] - (ii + 1);
 28811                         }
 28812                       for (n = row->used[TEXT_AREA]; ii < n; ++ii)
 28813                         {
 28814                           row->used[TEXT_AREA] = ii;
 28815                           if (row->mode_line_p)
 28816                             pad_mode_line (it, mode_line_p);
 28817                           else
 28818                             produce_special_glyphs (it, IT_TRUNCATION);
 28819                         }
 28820                     }
 28821                   produce_special_glyphs (it, IT_TRUNCATION);
 28822                 }
 28823               row->truncated_on_right_p = true;
 28824             }
 28825           break;
 28826         }
 28827     }
 28828 
 28829   /* Maybe insert a truncation at the left.  */
 28830   if (it->first_visible_x
 28831       && it_charpos > 0)
 28832     {
 28833       if (!FRAME_WINDOW_P (it->f)
 28834           || (row->reversed_p
 28835               ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
 28836               : WINDOW_LEFT_FRINGE_WIDTH (it->w)) == 0)
 28837         insert_left_trunc_glyphs (it);
 28838       row->truncated_on_left_p = true;
 28839     }
 28840 
 28841   it->face_id = saved_face_id;
 28842 
 28843   /* Value is number of columns displayed.  */
 28844   return it->hpos - hpos_at_start;
 28845 }
 28846 
 28847 
 28848 
 28849 /* This is like a combination of memq and assq.  Return 1/2 if PROPVAL
 28850    appears as an element of LIST or as the car of an element of LIST.
 28851    If PROPVAL is a list, compare each element against LIST in that
 28852    way, and return 1/2 if any element of PROPVAL is found in LIST.
 28853    Otherwise return 0.  This function cannot quit.
 28854    The return value is 2 if the text is invisible but with an ellipsis
 28855    and 1 if it's invisible and without an ellipsis.  */
 28856 
 28857 int
 28858 invisible_prop (Lisp_Object propval, Lisp_Object list)
 28859 {
 28860   Lisp_Object tail, proptail;
 28861 
 28862   for (tail = list; CONSP (tail); tail = XCDR (tail))
 28863     {
 28864       register Lisp_Object tem;
 28865       tem = XCAR (tail);
 28866       if (EQ (propval, tem))
 28867         return 1;
 28868       if (CONSP (tem) && EQ (propval, XCAR (tem)))
 28869         return NILP (XCDR (tem)) ? 1 : 2;
 28870     }
 28871 
 28872   if (CONSP (propval))
 28873     {
 28874       for (proptail = propval; CONSP (proptail); proptail = XCDR (proptail))
 28875         {
 28876           Lisp_Object propelt;
 28877           propelt = XCAR (proptail);
 28878           for (tail = list; CONSP (tail); tail = XCDR (tail))
 28879             {
 28880               register Lisp_Object tem;
 28881               tem = XCAR (tail);
 28882               if (EQ (propelt, tem))
 28883                 return 1;
 28884               if (CONSP (tem) && EQ (propelt, XCAR (tem)))
 28885                 return NILP (XCDR (tem)) ? 1 : 2;
 28886             }
 28887         }
 28888     }
 28889 
 28890   return 0;
 28891 }
 28892 
 28893 DEFUN ("invisible-p", Finvisible_p, Sinvisible_p, 1, 1, 0,
 28894        doc: /* Non-nil if text properties at POS cause text there to be currently invisible.
 28895 POS should be a marker or a buffer position; the value of the `invisible'
 28896 property at that position in the current buffer is examined.
 28897 POS can also be the actual value of the `invisible' text or overlay
 28898 property of the text of interest, in which case the value itself is
 28899 examined.
 28900 
 28901 The non-nil value returned can be t for currently invisible text that is
 28902 entirely hidden on display, or some other non-nil, non-t value if the
 28903 text is replaced by an ellipsis.
 28904 
 28905 Note that whether text with `invisible' property is actually hidden on
 28906 display may depend on `buffer-invisibility-spec', which see.  */)
 28907   (Lisp_Object pos)
 28908 {
 28909   Lisp_Object prop
 28910     = (FIXNATP (pos) || MARKERP (pos)
 28911        ? Fget_char_property (pos, Qinvisible, Qnil)
 28912        : pos);
 28913   int invis = TEXT_PROP_MEANS_INVISIBLE (prop);
 28914   return (invis == 0 ? Qnil
 28915           : invis == 1 ? Qt
 28916           : make_fixnum (invis));
 28917 }
 28918 
 28919 /* Calculate a width or height in pixels from a specification using
 28920    the following elements:
 28921 
 28922    SPEC ::=
 28923      NUM      - a (fractional) multiple of the default font width/height
 28924      (NUM)    - specifies exactly NUM pixels
 28925      UNIT     - a fixed number of pixels, see below.
 28926      ELEMENT  - size of a display element in pixels, see below.
 28927      (NUM . SPEC) - equals NUM * SPEC
 28928      (+ SPEC SPEC ...)  - add pixel values
 28929      (- SPEC SPEC ...)  - subtract pixel values
 28930      (- SPEC)           - negate pixel value
 28931 
 28932    NUM ::=
 28933      INT or FLOAT   - a number constant
 28934      SYMBOL         - use symbol's (buffer local) variable binding.
 28935 
 28936    UNIT ::=
 28937      in       - pixels per inch  *)
 28938      mm       - pixels per 1/1000 meter  *)
 28939      cm       - pixels per 1/100 meter   *)
 28940      width    - width of current font in pixels.
 28941      height   - height of current font in pixels.
 28942 
 28943      *) using the ratio(s) defined in display-pixels-per-inch.
 28944 
 28945    ELEMENT ::=
 28946 
 28947      left-fringe          - left fringe width in pixels
 28948      right-fringe         - right fringe width in pixels
 28949 
 28950      left-margin          - left margin width in pixels
 28951      right-margin         - right margin width in pixels
 28952 
 28953      scroll-bar           - scroll-bar area width in pixels
 28954 
 28955    Examples:
 28956 
 28957    Pixels corresponding to 5 inches:
 28958      (5 . in)
 28959 
 28960    Total width of non-text areas on left side of window (if scroll-bar is on left):
 28961      '(space :width (+ left-fringe left-margin scroll-bar))
 28962 
 28963    Align to first text column (in header line):
 28964      '(space :align-to 0)
 28965 
 28966    Align to middle of text area minus half the width of variable `my-image'
 28967    containing a loaded image:
 28968      '(space :align-to (0.5 . (- text my-image)))
 28969 
 28970    Width of left margin minus width of 1 character in the default font:
 28971      '(space :width (- left-margin 1))
 28972 
 28973    Width of left margin minus width of 2 characters in the current font:
 28974      '(space :width (- left-margin (2 . width)))
 28975 
 28976    Center 1 character over left-margin (in header line):
 28977      '(space :align-to (+ left-margin (0.5 . left-margin) -0.5))
 28978 
 28979    Different ways to express width of left fringe plus left margin minus one pixel:
 28980      '(space :width (- (+ left-fringe left-margin) (1)))
 28981      '(space :width (+ left-fringe left-margin (- (1))))
 28982      '(space :width (+ left-fringe left-margin (-1)))
 28983 
 28984    If ALIGN_TO is NULL, returns the result in *RES.  If ALIGN_TO is
 28985    non-NULL, the value of *ALIGN_TO is a window-relative pixel
 28986    coordinate, and *RES is the additional pixel width from that point
 28987    till the end of the stretch glyph.
 28988 
 28989    WIDTH_P non-zero means take the width dimension or X coordinate of
 28990    the object specified by PROP, WIDTH_P zero means take the height
 28991    dimension or the Y coordinate.  (Therefore, if ALIGN_TO is
 28992    non-NULL, WIDTH_P should be non-zero.)
 28993 
 28994    FONT is the font of the face of the surrounding text.
 28995 
 28996    The return value is non-zero if width or height were successfully
 28997    calculated, i.e. if PROP is a valid spec.  */
 28998 
 28999 static bool
 29000 calc_pixel_width_or_height (double *res, struct it *it, Lisp_Object prop,
 29001                             struct font *font, bool width_p, int *align_to)
 29002 {
 29003   /* Don't adjust for line number if we didn't yet produce it for this
 29004      screen line.  This is for when this function is called from
 29005      move_it_in_display_line_to that was called by display_line to get
 29006      past the glyphs hscrolled off the left side of the window.  */
 29007   int lnum_pixel_width = it->line_number_produced_p ? it->lnum_pixel_width : 0;
 29008   double pixels;
 29009 
 29010 # define OK_PIXELS(val) (*res = (val), true)
 29011 # define OK_ALIGN_TO(val) (*align_to = (val), true)
 29012 
 29013   if (NILP (prop))
 29014     return OK_PIXELS (0);
 29015 
 29016   eassert (FRAME_LIVE_P (it->f));
 29017 
 29018   if (SYMBOLP (prop))
 29019     {
 29020       if (SCHARS (SYMBOL_NAME (prop)) == 2)
 29021         {
 29022           char *unit = SSDATA (SYMBOL_NAME (prop));
 29023 
 29024           /* The UNIT expression, e.g. as part of (NUM . UNIT).  */
 29025           if (unit[0] == 'i' && unit[1] == 'n')
 29026             pixels = 1.0;
 29027           else if (unit[0] == 'm' && unit[1] == 'm')
 29028             pixels = 25.4;
 29029           else if (unit[0] == 'c' && unit[1] == 'm')
 29030             pixels = 2.54;
 29031           else
 29032             pixels = 0;
 29033           if (pixels > 0)
 29034             {
 29035               double ppi = (width_p ? FRAME_RES_X (it->f)
 29036                             : FRAME_RES_Y (it->f));
 29037 
 29038               if (ppi > 0)
 29039                 return OK_PIXELS (ppi / pixels);
 29040               return false;
 29041             }
 29042         }
 29043 
 29044 #ifdef HAVE_WINDOW_SYSTEM
 29045       /* 'height': the height of FONT.  */
 29046       if (EQ (prop, Qheight))
 29047         return OK_PIXELS (font
 29048                           ? normal_char_height (font, -1)
 29049                           : FRAME_LINE_HEIGHT (it->f));
 29050       /* 'width': the width of FONT.  */
 29051       if (EQ (prop, Qwidth))
 29052         return OK_PIXELS (font
 29053                           ? FONT_WIDTH (font)
 29054                           : FRAME_COLUMN_WIDTH (it->f));
 29055 #else
 29056       if (EQ (prop, Qheight) || EQ (prop, Qwidth))
 29057         return OK_PIXELS (1);
 29058 #endif
 29059 
 29060       /* 'text': the width or height of the text area.  */
 29061       if (EQ (prop, Qtext))
 29062           return OK_PIXELS (width_p
 29063                             ? (window_box_width (it->w, TEXT_AREA)
 29064                                - lnum_pixel_width)
 29065                             : WINDOW_BOX_HEIGHT_NO_MODE_LINE (it->w));
 29066 
 29067       /* ':align_to'.  First time we compute the value, window
 29068          elements are interpreted as the position of the element's
 29069          left edge.  */
 29070       if (align_to && *align_to < 0)
 29071         {
 29072           *res = 0;
 29073           /* 'left': left edge of the text area.  */
 29074           if (EQ (prop, Qleft))
 29075             return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA)
 29076                                 + lnum_pixel_width);
 29077           /* 'right': right edge of the text area.  */
 29078           if (EQ (prop, Qright))
 29079             return OK_ALIGN_TO (window_box_right_offset (it->w, TEXT_AREA));
 29080           /* 'center': the center of the text area.  */
 29081           if (EQ (prop, Qcenter))
 29082             return OK_ALIGN_TO (window_box_left_offset (it->w, TEXT_AREA)
 29083                                 + lnum_pixel_width
 29084                                 + window_box_width (it->w, TEXT_AREA) / 2);
 29085           /* 'left-fringe': left edge of the left fringe.  */
 29086           if (EQ (prop, Qleft_fringe))
 29087             return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
 29088                                 ? WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (it->w)
 29089                                 : window_box_right_offset (it->w, LEFT_MARGIN_AREA));
 29090           /* 'right-fringe': left edge of the right fringe.  */
 29091           if (EQ (prop, Qright_fringe))
 29092             return OK_ALIGN_TO (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
 29093                                 ? window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
 29094                                 : window_box_right_offset (it->w, TEXT_AREA));
 29095           /* 'left-margin': left edge of the left display margin.  */
 29096           if (EQ (prop, Qleft_margin))
 29097             return OK_ALIGN_TO (window_box_left_offset (it->w, LEFT_MARGIN_AREA));
 29098           /* 'right-margin': left edge of the right display margin.  */
 29099           if (EQ (prop, Qright_margin))
 29100             return OK_ALIGN_TO (window_box_left_offset (it->w, RIGHT_MARGIN_AREA));
 29101           /* 'scroll-bar': left edge of the vertical scroll bar.  */
 29102           if (EQ (prop, Qscroll_bar))
 29103             return OK_ALIGN_TO (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (it->w)
 29104                                 ? 0
 29105                                 : (window_box_right_offset (it->w, RIGHT_MARGIN_AREA)
 29106                                    + (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (it->w)
 29107                                       ? WINDOW_RIGHT_FRINGE_WIDTH (it->w)
 29108                                       : 0)));
 29109         }
 29110       else
 29111         {
 29112           /* Otherwise, the elements stand for their width.  */
 29113           if (EQ (prop, Qleft_fringe))
 29114             return OK_PIXELS (WINDOW_LEFT_FRINGE_WIDTH (it->w));
 29115           if (EQ (prop, Qright_fringe))
 29116             return OK_PIXELS (WINDOW_RIGHT_FRINGE_WIDTH (it->w));
 29117           if (EQ (prop, Qleft_margin))
 29118             return OK_PIXELS (WINDOW_LEFT_MARGIN_WIDTH (it->w));
 29119           if (EQ (prop, Qright_margin))
 29120             return OK_PIXELS (WINDOW_RIGHT_MARGIN_WIDTH (it->w));
 29121           if (EQ (prop, Qscroll_bar))
 29122             return OK_PIXELS (WINDOW_SCROLL_BAR_AREA_WIDTH (it->w));
 29123         }
 29124 
 29125       prop = buffer_local_value (prop, it->w->contents);
 29126       if (BASE_EQ (prop, Qunbound))
 29127         prop = Qnil;
 29128     }
 29129 
 29130   if (NUMBERP (prop))
 29131     {
 29132       int base_unit = (width_p
 29133                        ? FRAME_COLUMN_WIDTH (it->f)
 29134                        : FRAME_LINE_HEIGHT (it->f));
 29135       if (width_p && align_to && *align_to < 0)
 29136         return OK_PIXELS (XFLOATINT (prop) * base_unit + lnum_pixel_width);
 29137       return OK_PIXELS (XFLOATINT (prop) * base_unit);
 29138     }
 29139 
 29140   if (CONSP (prop))
 29141     {
 29142       Lisp_Object car = XCAR (prop);
 29143       Lisp_Object cdr = XCDR (prop);
 29144 
 29145       if (SYMBOLP (car))
 29146         {
 29147 #ifdef HAVE_WINDOW_SYSTEM
 29148           /* '(image PROPS...)': width or height of the specified image.  */
 29149           if (FRAME_WINDOW_P (it->f)
 29150               && valid_image_p (prop))
 29151             {
 29152               ptrdiff_t id = lookup_image (it->f, prop, it->face_id);
 29153               struct image *img = IMAGE_FROM_ID (it->f, id);
 29154 
 29155               return OK_PIXELS (width_p ? img->width : img->height);
 29156             }
 29157           /* '(xwidget PROPS...)': dimensions of the specified xwidget.  */
 29158           if (FRAME_WINDOW_P (it->f) && valid_xwidget_spec_p (prop))
 29159             {
 29160               /* TODO: Don't return dummy size.  */
 29161               return OK_PIXELS (100);
 29162             }
 29163 #endif
 29164           /* '(+ EXPR...)' or '(- EXPR...)' add or subtract
 29165              recursively calculated values.  */
 29166           if (EQ (car, Qplus) || EQ (car, Qminus))
 29167             {
 29168               bool first = true;
 29169               double px;
 29170 
 29171               pixels = 0;
 29172               while (CONSP (cdr))
 29173                 {
 29174                   if (!calc_pixel_width_or_height (&px, it, XCAR (cdr),
 29175                                                    font, width_p, align_to))
 29176                     return false;
 29177                   if (first)
 29178                     pixels = (EQ (car, Qplus) ? px : -px), first = false;
 29179                   else
 29180                     pixels += px;
 29181                   cdr = XCDR (cdr);
 29182                 }
 29183               if (EQ (car, Qminus))
 29184                 pixels = -pixels;
 29185               return OK_PIXELS (pixels);
 29186             }
 29187 
 29188           car = buffer_local_value (car, it->w->contents);
 29189           if (BASE_EQ (car, Qunbound))
 29190             car = Qnil;
 29191         }
 29192 
 29193       /* '(NUM)': absolute number of pixels.  */
 29194       if (NUMBERP (car))
 29195         {
 29196           double fact;
 29197           int offset =
 29198             width_p && align_to && *align_to < 0 ? lnum_pixel_width : 0;
 29199           pixels = XFLOATINT (car);
 29200           if (NILP (cdr))
 29201             return OK_PIXELS (pixels + offset);
 29202           if (calc_pixel_width_or_height (&fact, it, cdr,
 29203                                           font, width_p, align_to))
 29204             return OK_PIXELS (pixels * fact + offset);
 29205           return false;
 29206         }
 29207 
 29208       return false;
 29209     }
 29210 
 29211   return false;
 29212 }
 29213 
 29214 void
 29215 get_font_ascent_descent (struct font *font, int *ascent, int *descent)
 29216 {
 29217 #ifdef HAVE_WINDOW_SYSTEM
 29218   normal_char_ascent_descent (font, -1, ascent, descent);
 29219 #else
 29220   *ascent = 1;
 29221   *descent = 0;
 29222 #endif
 29223 }
 29224 
 29225 
 29226 /***********************************************************************
 29227                              Glyph Display
 29228  ***********************************************************************/
 29229 
 29230 #ifdef HAVE_WINDOW_SYSTEM
 29231 
 29232 #ifdef GLYPH_DEBUG
 29233 
 29234 extern void dump_glyph_string (struct glyph_string *) EXTERNALLY_VISIBLE;
 29235 void
 29236 dump_glyph_string (struct glyph_string *s)
 29237 {
 29238   fputs ("glyph string\n", stderr);
 29239   fprintf (stderr, "  x, y, w, h = %d, %d, %d, %d\n",
 29240            s->x, s->y, s->width, s->height);
 29241   fprintf (stderr, "  ybase = %d\n", s->ybase);
 29242   fprintf (stderr, "  hl = %u\n", s->hl);
 29243   fprintf (stderr, "  left overhang = %d, right = %d\n",
 29244            s->left_overhang, s->right_overhang);
 29245   fprintf (stderr, "  nchars = %d\n", s->nchars);
 29246   fprintf (stderr, "  extends to end of line = %d\n",
 29247            s->extends_to_end_of_line_p);
 29248   fprintf (stderr, "  font height = %d\n", FONT_HEIGHT (s->font));
 29249   fprintf (stderr, "  bg width = %d\n", s->background_width);
 29250 }
 29251 
 29252 #endif /* GLYPH_DEBUG */
 29253 
 29254 /* Initialize glyph string S.  CHAR2B is a suitably allocated vector
 29255    of 2-byte unsigned integers for S; it can't be allocated in
 29256    init_glyph_string because it must be allocated via `alloca'.  W
 29257    is the window on which S is drawn.  ROW and AREA are the glyph row
 29258    and area within the row from which S is constructed.  START is the
 29259    index of the first glyph structure covered by S.  HL is a
 29260    face-override for drawing S.  */
 29261 
 29262 #ifdef HAVE_NTGUI
 29263 /* We set inhibit-quit here due to paranoia: get_frame_dc acquires the
 29264    critical section, and we cannot QUIT while we hold the critical
 29265    section.  If any of the code run by callers of ALLOCATE_HDC happens
 29266    to call Lisp (might be possible due to all the hooks lying around),
 29267    we must prevent it from quitting.  */
 29268 # define ALLOCATE_HDC(hdc, f)                   \
 29269   Lisp_Object prev_quit = Vinhibit_quit;        \
 29270   Vinhibit_quit = Qt;                           \
 29271   HDC hdc = get_frame_dc ((f))
 29272 # define RELEASE_HDC(hdc, f)                    \
 29273   release_frame_dc ((f), (hdc));                \
 29274   Vinhibit_quit = prev_quit
 29275 #else
 29276 # define ALLOCATE_HDC(hdc, f)
 29277 # define RELEASE_HDC(hdc, f)
 29278 #endif
 29279 
 29280 static void
 29281 init_glyph_string (struct glyph_string *s,
 29282 #ifdef HAVE_NTGUI
 29283                    HDC hdc,
 29284 #endif
 29285                    unsigned *char2b, struct window *w, struct glyph_row *row,
 29286                    enum glyph_row_area area, int start, enum draw_glyphs_face hl)
 29287 {
 29288   memset (s, 0, sizeof *s);
 29289   s->w = w;
 29290   s->f = XFRAME (w->frame);
 29291 #ifdef HAVE_NTGUI
 29292   s->hdc = hdc;
 29293 #endif
 29294   s->char2b = char2b;
 29295   s->hl = hl;
 29296   s->row = row;
 29297   s->area = area;
 29298   s->first_glyph = row->glyphs[area] + start;
 29299   s->height = row->height;
 29300   s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
 29301   s->ybase = s->y + row->ascent;
 29302 }
 29303 
 29304 
 29305 /* Append the list of glyph strings with head H and tail T to the list
 29306    with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the result.  */
 29307 
 29308 static void
 29309 append_glyph_string_lists (struct glyph_string **head, struct glyph_string **tail,
 29310                            struct glyph_string *h, struct glyph_string *t)
 29311 {
 29312   if (h)
 29313     {
 29314       if (*head)
 29315         (*tail)->next = h;
 29316       else
 29317         *head = h;
 29318       h->prev = *tail;
 29319       *tail = t;
 29320     }
 29321 }
 29322 
 29323 
 29324 /* Prepend the list of glyph strings with head H and tail T to the
 29325    list with head *HEAD and tail *TAIL.  Set *HEAD and *TAIL to the
 29326    result.  */
 29327 
 29328 static void
 29329 prepend_glyph_string_lists (struct glyph_string **head, struct glyph_string **tail,
 29330                             struct glyph_string *h, struct glyph_string *t)
 29331 {
 29332   if (h)
 29333     {
 29334       if (*head)
 29335         (*head)->prev = t;
 29336       else
 29337         *tail = t;
 29338       t->next = *head;
 29339       *head = h;
 29340     }
 29341 }
 29342 
 29343 
 29344 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
 29345    Set *HEAD and *TAIL to the resulting list.  */
 29346 
 29347 static void
 29348 append_glyph_string (struct glyph_string **head, struct glyph_string **tail,
 29349                      struct glyph_string *s)
 29350 {
 29351   s->next = s->prev = NULL;
 29352   append_glyph_string_lists (head, tail, s, s);
 29353 }
 29354 
 29355 
 29356 /* Get face and two-byte form of character C in face FACE_ID on frame F.
 29357    The encoding of C is returned in *CHAR2B.  DISPLAY_P means
 29358    make sure that X resources for the face returned are allocated.
 29359    Value is a pointer to a realized face that is ready for display if
 29360    DISPLAY_P.  */
 29361 
 29362 static struct face *
 29363 get_char_face_and_encoding (struct frame *f, int c, int face_id,
 29364                             unsigned *char2b, bool display_p)
 29365 {
 29366   struct face *face = FACE_FROM_ID (f, face_id);
 29367   unsigned code = 0;
 29368 
 29369   if (face->font)
 29370     {
 29371       code = face->font->driver->encode_char (face->font, c);
 29372 
 29373       if (code == FONT_INVALID_CODE)
 29374         code = 0;
 29375     }
 29376   /* Ensure that the code is only 2 bytes wide.  */
 29377   *char2b = code & 0xFFFF;
 29378 
 29379   /* Make sure X resources of the face are allocated.  */
 29380 #ifdef HAVE_X_WINDOWS
 29381   if (display_p)
 29382 #endif
 29383     {
 29384       eassert (face != NULL);
 29385       prepare_face_for_display (f, face);
 29386     }
 29387 
 29388   return face;
 29389 }
 29390 
 29391 
 29392 /* Get face and two-byte form of character glyph GLYPH on frame F.
 29393    The encoding of GLYPH->u.ch is returned in *CHAR2B.  Value is
 29394    a pointer to a realized face that is ready for display.  */
 29395 
 29396 static struct face *
 29397 get_glyph_face_and_encoding (struct frame *f, struct glyph *glyph,
 29398                              unsigned *char2b)
 29399 {
 29400   struct face *face;
 29401   unsigned code = 0;
 29402 
 29403   eassert (glyph->type == CHAR_GLYPH);
 29404   face = FACE_FROM_ID (f, glyph->face_id);
 29405 
 29406   /* Make sure X resources of the face are allocated.  */
 29407   prepare_face_for_display (f, face);
 29408 
 29409   if (face->font)
 29410     {
 29411       if (CHAR_BYTE8_P (glyph->u.ch))
 29412         code = CHAR_TO_BYTE8 (glyph->u.ch);
 29413       else
 29414         code = face->font->driver->encode_char (face->font, glyph->u.ch);
 29415 
 29416       if (code == FONT_INVALID_CODE)
 29417         code = 0;
 29418     }
 29419 
 29420   /* Ensure that the code is only 2 bytes wide.  */
 29421   *char2b = code & 0xFFFF;
 29422   return face;
 29423 }
 29424 
 29425 
 29426 /* Get glyph code of character C in FONT in the two-byte form CHAR2B.
 29427    Return true iff FONT has a glyph for C.  */
 29428 
 29429 static bool
 29430 get_char_glyph_code (int c, struct font *font, unsigned *char2b)
 29431 {
 29432   unsigned code;
 29433 
 29434   if (CHAR_BYTE8_P (c))
 29435     code = CHAR_TO_BYTE8 (c);
 29436   else
 29437     code = font->driver->encode_char (font, c);
 29438 
 29439   if (code == FONT_INVALID_CODE)
 29440     return false;
 29441 
 29442   /* Ensure that the code is only 2 bytes wide.  */
 29443   *char2b = code & 0xFFFF;
 29444   return true;
 29445 }
 29446 
 29447 
 29448 /* Fill glyph string S with composition components specified by S->cmp.
 29449 
 29450    BASE_FACE is the base face of the composition.
 29451    S->cmp_from is the index of the first component for S.
 29452 
 29453    OVERLAPS non-zero means S should draw the foreground only, and use
 29454    its physical height for clipping.  See also draw_glyphs.
 29455 
 29456    Value is the index of a component not in S.  */
 29457 
 29458 static int
 29459 fill_composite_glyph_string (struct glyph_string *s, struct face *base_face,
 29460                              int overlaps)
 29461 {
 29462   int i;
 29463   /* For all glyphs of this composition, starting at the offset
 29464      S->cmp_from, until we reach the end of the definition or encounter a
 29465      glyph that requires the different face, add it to S.  */
 29466   struct face *face;
 29467 
 29468   eassert (s);
 29469 
 29470   s->for_overlaps = overlaps;
 29471   s->face = NULL;
 29472   s->font = NULL;
 29473   for (i = s->cmp_from; i < s->cmp->glyph_len; i++)
 29474     {
 29475       int c = COMPOSITION_GLYPH (s->cmp, i);
 29476 
 29477       /* TAB in a composition means display glyphs with padding space
 29478          on the left or right.  */
 29479       if (c != '\t')
 29480         {
 29481           int face_id = FACE_FOR_CHAR (s->f, base_face->ascii_face, c,
 29482                                        -1, Qnil);
 29483 
 29484           face = get_char_face_and_encoding (s->f, c, face_id,
 29485                                              s->char2b + i, true);
 29486           if (face)
 29487             {
 29488               if (! s->face)
 29489                 {
 29490                   s->face = face;
 29491                   s->font = s->face->font;
 29492                 }
 29493               else if (s->face != face)
 29494                 break;
 29495             }
 29496         }
 29497       ++s->nchars;
 29498     }
 29499   s->cmp_to = i;
 29500 
 29501   if (s->face == NULL)
 29502     {
 29503       s->face = base_face->ascii_face;
 29504       s->font = s->face->font;
 29505     }
 29506 
 29507   if (s->hl == DRAW_MOUSE_FACE
 29508       || (s->hl == DRAW_CURSOR
 29509           && MATRIX_ROW (s->w->current_matrix,
 29510                          s->w->phys_cursor.vpos)->mouse_face_p
 29511           && cursor_in_mouse_face_p (s->w)))
 29512     {
 29513       int c = COMPOSITION_GLYPH (s->cmp, 0);
 29514       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29515       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29516       if (!s->face)
 29517         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29518 
 29519       s->face = FACE_FROM_ID (s->f, FACE_FOR_CHAR (s->f, s->face, c, -1, Qnil));
 29520       prepare_face_for_display (s->f, s->face);
 29521     }
 29522 
 29523   /* All glyph strings for the same composition has the same width,
 29524      i.e. the width set for the first component of the composition.  */
 29525   s->width = s->first_glyph->pixel_width;
 29526 
 29527   /* If the specified font could not be loaded, use the frame's
 29528      default font, but record the fact that we couldn't load it in
 29529      the glyph string so that we can draw rectangles for the
 29530      characters of the glyph string.  */
 29531   if (s->font == NULL)
 29532     {
 29533       s->font_not_found_p = true;
 29534       s->font = FRAME_FONT (s->f);
 29535     }
 29536 
 29537   /* Adjust base line for subscript/superscript text.  */
 29538   s->ybase += s->first_glyph->voffset;
 29539 
 29540   return s->cmp_to;
 29541 }
 29542 
 29543 static int
 29544 fill_gstring_glyph_string (struct glyph_string *s, int face_id,
 29545                            int start, int end, int overlaps)
 29546 {
 29547   struct glyph *glyph, *last;
 29548   int voffset;
 29549   Lisp_Object lgstring;
 29550   int i;
 29551   bool glyph_not_available_p;
 29552 
 29553   s->for_overlaps = overlaps;
 29554   glyph = s->row->glyphs[s->area] + start;
 29555   last = s->row->glyphs[s->area] + end;
 29556   voffset = glyph->voffset;
 29557   glyph_not_available_p = glyph->glyph_not_available_p;
 29558   s->cmp_id = glyph->u.cmp.id;
 29559   s->cmp_from = glyph->slice.cmp.from;
 29560   s->cmp_to = glyph->slice.cmp.to + 1;
 29561   if (s->hl == DRAW_MOUSE_FACE
 29562       || (s->hl == DRAW_CURSOR
 29563           && MATRIX_ROW (s->w->current_matrix,
 29564                          s->w->phys_cursor.vpos)->mouse_face_p
 29565           && cursor_in_mouse_face_p (s->w)))
 29566     {
 29567       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29568       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29569       if (!s->face)
 29570         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29571       prepare_face_for_display (s->f, s->face);
 29572     }
 29573   else
 29574     s->face = FACE_FROM_ID (s->f, face_id);
 29575   lgstring = composition_gstring_from_id (s->cmp_id);
 29576   s->font = XFONT_OBJECT (LGSTRING_FONT (lgstring));
 29577   /* The width of a composition glyph string is the sum of the
 29578      composition's glyph widths.  */
 29579   s->width = s->first_glyph->pixel_width;
 29580   glyph++;
 29581   while (glyph < last
 29582          && glyph->u.cmp.automatic
 29583          && glyph->u.cmp.id == s->cmp_id
 29584          && glyph->face_id == face_id
 29585          && s->cmp_to == glyph->slice.cmp.from
 29586          && glyph->glyph_not_available_p == glyph_not_available_p)
 29587     {
 29588       s->width += glyph->pixel_width;
 29589       s->cmp_to = (glyph++)->slice.cmp.to + 1;
 29590     }
 29591 
 29592   for (i = s->cmp_from; i < s->cmp_to; i++)
 29593     {
 29594       Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i);
 29595       unsigned code = LGLYPH_CODE (lglyph);
 29596 
 29597       /* Ensure that the code is only 2 bytes wide.  */
 29598       s->char2b[i] = code & 0xFFFF;
 29599     }
 29600 
 29601   /* If the specified font could not be loaded, record that fact in
 29602      S->font_not_found_p so that we can draw rectangles for the
 29603      characters of the glyph string.  */
 29604   if (glyph_not_available_p)
 29605     s->font_not_found_p = true;
 29606 
 29607   /* Adjust base line for subscript/superscript text.  */
 29608   s->ybase += voffset;
 29609 
 29610   return glyph - s->row->glyphs[s->area];
 29611 }
 29612 
 29613 
 29614 /* Fill glyph string S from a sequence glyphs for glyphless characters.
 29615    See the comment of fill_glyph_string for arguments.
 29616    Value is the index of the first glyph not in S.  */
 29617 
 29618 
 29619 static int
 29620 fill_glyphless_glyph_string (struct glyph_string *s, int face_id,
 29621                              int start, int end, int overlaps)
 29622 {
 29623   struct glyph *glyph, *last;
 29624   int voffset;
 29625 
 29626   eassert (s->first_glyph->type == GLYPHLESS_GLYPH);
 29627   s->for_overlaps = overlaps;
 29628   glyph = s->row->glyphs[s->area] + start;
 29629   last = s->row->glyphs[s->area] + end;
 29630   voffset = glyph->voffset;
 29631   s->face = FACE_FROM_ID (s->f, face_id);
 29632   s->font = s->face->font ? s->face->font : FRAME_FONT (s->f);
 29633   if (s->hl == DRAW_MOUSE_FACE
 29634       || (s->hl == DRAW_CURSOR
 29635           && MATRIX_ROW (s->w->current_matrix,
 29636                          s->w->phys_cursor.vpos)->mouse_face_p
 29637           && cursor_in_mouse_face_p (s->w)))
 29638     {
 29639       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29640       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29641       if (!s->face)
 29642         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29643       prepare_face_for_display (s->f, s->face);
 29644     }
 29645   s->nchars = 1;
 29646   s->width = glyph->pixel_width;
 29647   glyph++;
 29648   while (glyph < last
 29649          && glyph->type == GLYPHLESS_GLYPH
 29650          && glyph->voffset == voffset
 29651          && glyph->face_id == face_id)
 29652     {
 29653       s->nchars++;
 29654       s->width += glyph->pixel_width;
 29655       glyph++;
 29656     }
 29657   s->ybase += voffset;
 29658   return glyph - s->row->glyphs[s->area];
 29659 }
 29660 
 29661 
 29662 /* Fill glyph string S from a sequence of character glyphs.
 29663 
 29664    FACE_ID is the face id of the string.  START is the index of the
 29665    first glyph to consider, END is the index of the last + 1.
 29666    OVERLAPS non-zero means S should draw the foreground only, and use
 29667    its physical height for clipping.  See also draw_glyphs.
 29668 
 29669    Value is the index of the first glyph not in S.  */
 29670 
 29671 static int
 29672 fill_glyph_string (struct glyph_string *s, int face_id,
 29673                    int start, int end, int overlaps)
 29674 {
 29675   struct glyph *glyph, *last;
 29676   int voffset;
 29677   bool glyph_not_available_p;
 29678 
 29679   eassert (s->f == XFRAME (s->w->frame));
 29680   eassert (s->nchars == 0);
 29681   eassert (start >= 0 && end > start);
 29682 
 29683   s->for_overlaps = overlaps;
 29684   glyph = s->row->glyphs[s->area] + start;
 29685   last = s->row->glyphs[s->area] + end;
 29686   voffset = glyph->voffset;
 29687   s->padding_p = glyph->padding_p;
 29688   glyph_not_available_p = glyph->glyph_not_available_p;
 29689 
 29690   while (glyph < last
 29691          && glyph->type == CHAR_GLYPH
 29692          && glyph->voffset == voffset
 29693          /* Same face id implies same font, nowadays.  */
 29694          && glyph->face_id == face_id
 29695          && glyph->glyph_not_available_p == glyph_not_available_p)
 29696     {
 29697       s->face = get_glyph_face_and_encoding (s->f, glyph,
 29698                                              s->char2b + s->nchars);
 29699       ++s->nchars;
 29700       eassert (s->nchars <= end - start);
 29701       s->width += glyph->pixel_width;
 29702       if (glyph++->padding_p != s->padding_p)
 29703         break;
 29704     }
 29705 
 29706   s->font = s->face->font;
 29707 
 29708   if (s->hl == DRAW_MOUSE_FACE
 29709       || (s->hl == DRAW_CURSOR
 29710           && MATRIX_ROW (s->w->current_matrix,
 29711                          s->w->phys_cursor.vpos)->mouse_face_p
 29712           && cursor_in_mouse_face_p (s->w)))
 29713     {
 29714       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29715       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29716       if (!s->face)
 29717         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29718       s->face
 29719         = FACE_FROM_ID (s->f, FACE_FOR_CHAR (s->f, s->face,
 29720                                              s->first_glyph->u.ch, -1, Qnil));
 29721       prepare_face_for_display (s->f, s->face);
 29722     }
 29723 
 29724   /* If the specified font could not be loaded, use the frame's font,
 29725      but record the fact that we couldn't load it in
 29726      S->font_not_found_p so that we can draw rectangles for the
 29727      characters of the glyph string.  */
 29728   if (s->font == NULL || glyph_not_available_p)
 29729     {
 29730       s->font_not_found_p = true;
 29731       s->font = FRAME_FONT (s->f);
 29732     }
 29733 
 29734   /* Adjust base line for subscript/superscript text.  */
 29735   s->ybase += voffset;
 29736 
 29737   eassert (s->face && s->face->gc);
 29738   return glyph - s->row->glyphs[s->area];
 29739 }
 29740 
 29741 
 29742 /* Fill glyph string S from image glyph S->first_glyph.  */
 29743 
 29744 static void
 29745 fill_image_glyph_string (struct glyph_string *s)
 29746 {
 29747   eassert (s->first_glyph->type == IMAGE_GLYPH);
 29748   s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
 29749   eassert (s->img);
 29750   s->slice = s->first_glyph->slice.img;
 29751   s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
 29752   s->font = s->face->font;
 29753   if (s->hl == DRAW_MOUSE_FACE
 29754       || (s->hl == DRAW_CURSOR
 29755           && MATRIX_ROW (s->w->current_matrix,
 29756                          s->w->phys_cursor.vpos)->mouse_face_p
 29757           && cursor_in_mouse_face_p (s->w)))
 29758     {
 29759       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29760       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29761       if (!s->face)
 29762         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29763       prepare_face_for_display (s->f, s->face);
 29764     }
 29765   s->width = s->first_glyph->pixel_width;
 29766 
 29767   /* Adjust base line for subscript/superscript text.  */
 29768   s->ybase += s->first_glyph->voffset;
 29769 }
 29770 
 29771 
 29772 #ifdef HAVE_XWIDGETS
 29773 static void
 29774 fill_xwidget_glyph_string (struct glyph_string *s)
 29775 {
 29776   eassert (s->first_glyph->type == XWIDGET_GLYPH);
 29777   s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
 29778   s->font = s->face->font;
 29779   if (s->hl == DRAW_MOUSE_FACE
 29780       || (s->hl == DRAW_CURSOR
 29781           && MATRIX_ROW (s->w->current_matrix,
 29782                          s->w->phys_cursor.vpos)->mouse_face_p
 29783           && cursor_in_mouse_face_p (s->w)))
 29784     {
 29785       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29786       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29787       if (!s->face)
 29788         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29789       prepare_face_for_display (s->f, s->face);
 29790     }
 29791   s->width = s->first_glyph->pixel_width;
 29792   s->ybase += s->first_glyph->voffset;
 29793   s->xwidget = xwidget_from_id (s->first_glyph->u.xwidget);
 29794 }
 29795 #endif
 29796 /* Fill glyph string S from a sequence of stretch glyphs.
 29797 
 29798    START is the index of the first glyph to consider,
 29799    END is the index of the last + 1.
 29800 
 29801    Value is the index of the first glyph not in S.  */
 29802 
 29803 static int
 29804 fill_stretch_glyph_string (struct glyph_string *s, int start, int end)
 29805 {
 29806   struct glyph *glyph, *last;
 29807   int voffset, face_id;
 29808 
 29809   eassert (s->first_glyph->type == STRETCH_GLYPH);
 29810 
 29811   glyph = s->row->glyphs[s->area] + start;
 29812   last = s->row->glyphs[s->area] + end;
 29813   face_id = glyph->face_id;
 29814   s->face = FACE_FROM_ID (s->f, face_id);
 29815   s->font = s->face->font;
 29816   if (s->hl == DRAW_MOUSE_FACE
 29817       || (s->hl == DRAW_CURSOR
 29818           && MATRIX_ROW (s->w->current_matrix,
 29819                          s->w->phys_cursor.vpos)->mouse_face_p
 29820           && cursor_in_mouse_face_p (s->w)))
 29821     {
 29822       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (s->f);
 29823       s->face = FACE_FROM_ID_OR_NULL (s->f, hlinfo->mouse_face_face_id);
 29824       if (!s->face)
 29825         s->face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
 29826       prepare_face_for_display (s->f, s->face);
 29827     }
 29828   s->width = glyph->pixel_width;
 29829   s->nchars = 1;
 29830   voffset = glyph->voffset;
 29831 
 29832   for (++glyph;
 29833        (glyph < last
 29834         && glyph->type == STRETCH_GLYPH
 29835         && glyph->voffset == voffset
 29836         && glyph->face_id == face_id);
 29837        ++glyph)
 29838     s->width += glyph->pixel_width;
 29839 
 29840   /* Adjust base line for subscript/superscript text.  */
 29841   s->ybase += voffset;
 29842 
 29843   /* The case that face->gc == 0 is handled when drawing the glyph
 29844      string by calling prepare_face_for_display.  */
 29845   eassert (s->face);
 29846   return glyph - s->row->glyphs[s->area];
 29847 }
 29848 
 29849 static struct font_metrics *
 29850 get_per_char_metric (struct font *font, const unsigned *char2b)
 29851 {
 29852   static struct font_metrics metrics;
 29853 
 29854   if (! font)
 29855     return NULL;
 29856   if (*char2b == FONT_INVALID_CODE)
 29857     return NULL;
 29858 
 29859   font->driver->text_extents (font, char2b, 1, &metrics);
 29860   return &metrics;
 29861 }
 29862 
 29863 /* A subroutine that computes "normal" values of ASCENT and DESCENT
 29864    for FONT.  Values are taken from font-global ones, except for fonts
 29865    that claim preposterously large values, but whose glyphs actually
 29866    have reasonable dimensions.  C is the character to use for metrics
 29867    if the font-global values are too large; if C is negative, the
 29868    function selects a default character.  */
 29869 static void
 29870 normal_char_ascent_descent (struct font *font, int c, int *ascent, int *descent)
 29871 {
 29872   *ascent = FONT_BASE (font);
 29873   *descent = FONT_DESCENT (font);
 29874 
 29875   if (FONT_TOO_HIGH (font))
 29876     {
 29877       unsigned char2b;
 29878 
 29879       /* Get metrics of C, defaulting to a reasonably sized ASCII
 29880          character.  */
 29881       if (get_char_glyph_code (c >= 0 ? c : '{', font, &char2b))
 29882         {
 29883           struct font_metrics *pcm = get_per_char_metric (font, &char2b);
 29884           eassume (pcm);
 29885 
 29886           if (!(pcm->width == 0 && pcm->rbearing == 0 && pcm->lbearing == 0))
 29887             {
 29888               /* We add 1 pixel to character dimensions as heuristics
 29889                  that produces nicer display, e.g. when the face has
 29890                  the box attribute.  */
 29891               *ascent = pcm->ascent + 1;
 29892               *descent = pcm->descent + 1;
 29893             }
 29894         }
 29895     }
 29896 }
 29897 
 29898 /* A subroutine that computes a reasonable "normal character height"
 29899    for fonts that claim preposterously large vertical dimensions, but
 29900    whose glyphs are actually reasonably sized.  C is the character
 29901    whose metrics to use for those fonts, or -1 for default
 29902    character.  */
 29903 static int
 29904 normal_char_height (struct font *font, int c)
 29905 {
 29906   int ascent, descent;
 29907 
 29908   normal_char_ascent_descent (font, c, &ascent, &descent);
 29909 
 29910   return ascent + descent;
 29911 }
 29912 
 29913 /* EXPORT for RIF:
 29914    Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
 29915    frame F.  Overhangs of glyphs other than type CHAR_GLYPH are
 29916    assumed to be zero.  */
 29917 
 29918 void
 29919 gui_get_glyph_overhangs (struct glyph *glyph, struct frame *f, int *left, int *right)
 29920 {
 29921   *left = *right = 0;
 29922 
 29923   if (glyph->type == CHAR_GLYPH)
 29924     {
 29925       unsigned char2b;
 29926       struct face *face = get_glyph_face_and_encoding (f, glyph, &char2b);
 29927       if (face->font)
 29928         {
 29929           struct font_metrics *pcm = get_per_char_metric (face->font, &char2b);
 29930           if (pcm)
 29931             {
 29932               if (pcm->rbearing > pcm->width)
 29933                 *right = pcm->rbearing - pcm->width;
 29934               if (pcm->lbearing < 0)
 29935                 *left = -pcm->lbearing;
 29936             }
 29937         }
 29938     }
 29939   else if (glyph->type == COMPOSITE_GLYPH)
 29940     {
 29941       if (! glyph->u.cmp.automatic)
 29942         {
 29943           struct composition *cmp = composition_table[glyph->u.cmp.id];
 29944 
 29945           if (cmp->rbearing > cmp->pixel_width)
 29946             *right = cmp->rbearing - cmp->pixel_width;
 29947           if (cmp->lbearing < 0)
 29948             *left = - cmp->lbearing;
 29949         }
 29950       else
 29951         {
 29952           Lisp_Object gstring = composition_gstring_from_id (glyph->u.cmp.id);
 29953           struct font_metrics metrics;
 29954 
 29955           composition_gstring_width (gstring, glyph->slice.cmp.from,
 29956                                      glyph->slice.cmp.to + 1, &metrics);
 29957           if (metrics.rbearing > metrics.width)
 29958             *right = metrics.rbearing - metrics.width;
 29959           if (metrics.lbearing < 0)
 29960             *left = - metrics.lbearing;
 29961         }
 29962     }
 29963 }
 29964 
 29965 
 29966 /* Return the index of the first glyph preceding glyph string S that
 29967    is overwritten by S because of S's left overhang.  Value is -1
 29968    if no glyphs are overwritten.  */
 29969 
 29970 static int
 29971 left_overwritten (struct glyph_string *s)
 29972 {
 29973   int k;
 29974 
 29975   if (s->left_overhang)
 29976     {
 29977       int x = 0, i;
 29978       struct glyph *glyphs = s->row->glyphs[s->area];
 29979       int first = s->first_glyph - glyphs;
 29980 
 29981       for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
 29982         x -= glyphs[i].pixel_width;
 29983 
 29984       k = i + 1;
 29985     }
 29986   else
 29987     k = -1;
 29988 
 29989   return k;
 29990 }
 29991 
 29992 
 29993 /* Return the index of the first glyph preceding glyph string S that
 29994    is overwriting S because of its right overhang.  Value is -1 if no
 29995    glyph in front of S overwrites S.  */
 29996 
 29997 static int
 29998 left_overwriting (struct glyph_string *s)
 29999 {
 30000   int i, k, x;
 30001   struct glyph *glyphs = s->row->glyphs[s->area];
 30002   int first = s->first_glyph - glyphs;
 30003 
 30004   k = -1;
 30005   x = 0;
 30006   for (i = first - 1; i >= 0; --i)
 30007     {
 30008       int left, right;
 30009       gui_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
 30010       if (x + right > 0)
 30011         k = i;
 30012       x -= glyphs[i].pixel_width;
 30013     }
 30014 
 30015   return k;
 30016 }
 30017 
 30018 
 30019 /* Return the index of the last glyph following glyph string S that is
 30020    overwritten by S because of S's right overhang.  Value is -1 if
 30021    no such glyph is found.  */
 30022 
 30023 static int
 30024 right_overwritten (struct glyph_string *s)
 30025 {
 30026   int k = -1;
 30027 
 30028   if (s->right_overhang)
 30029     {
 30030       int x = 0, i;
 30031       struct glyph *glyphs = s->row->glyphs[s->area];
 30032       int first = (s->first_glyph - glyphs
 30033                    + (s->first_glyph->type == COMPOSITE_GLYPH ? 1 : s->nchars));
 30034       int end = s->row->used[s->area];
 30035 
 30036       for (i = first; i < end && s->right_overhang > x; ++i)
 30037         x += glyphs[i].pixel_width;
 30038 
 30039       k = i;
 30040     }
 30041 
 30042   return k;
 30043 }
 30044 
 30045 
 30046 /* Return the index of the last glyph following glyph string S that
 30047    overwrites S because of its left overhang.  Value is negative
 30048    if no such glyph is found.  */
 30049 
 30050 static int
 30051 right_overwriting (struct glyph_string *s)
 30052 {
 30053   int i, k, x;
 30054   int end = s->row->used[s->area];
 30055   struct glyph *glyphs = s->row->glyphs[s->area];
 30056   int first = (s->first_glyph - glyphs
 30057                + (s->first_glyph->type == COMPOSITE_GLYPH ? 1 : s->nchars));
 30058 
 30059   k = -1;
 30060   x = 0;
 30061   for (i = first; i < end; ++i)
 30062     {
 30063       int left, right;
 30064       gui_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
 30065       if (x - left < 0)
 30066         k = i;
 30067       x += glyphs[i].pixel_width;
 30068     }
 30069 
 30070   return k;
 30071 }
 30072 
 30073 
 30074 /* Set background width of glyph string S.  START is the index of the
 30075    first glyph following S.  LAST_X is the right-most x-position + 1
 30076    in the drawing area.
 30077 
 30078    If S->hl is DRAW_CURSOR, S->f is a window system frame, and the
 30079    cursor in S's window is currently inside mouse face, also update
 30080    S->width to take into account potentially differing :box
 30081    properties between the original face and the mouse face.  */
 30082 
 30083 static void
 30084 set_glyph_string_background_width (struct glyph_string *s, int start, int last_x)
 30085 {
 30086   /* If the face of this glyph string has to be drawn to the end of
 30087      the drawing area, set S->extends_to_end_of_line_p.  */
 30088 
 30089   if (start == s->row->used[s->area]
 30090       && ((s->row->fill_line_p
 30091            && (s->hl == DRAW_NORMAL_TEXT
 30092                || s->hl == DRAW_IMAGE_RAISED
 30093                || s->hl == DRAW_IMAGE_SUNKEN))
 30094           || s->hl == DRAW_MOUSE_FACE))
 30095     s->extends_to_end_of_line_p = true;
 30096 
 30097   /* If S extends its face to the end of the line, set its
 30098      background_width to the distance to the right edge of the drawing
 30099      area.  */
 30100   if (s->extends_to_end_of_line_p)
 30101     s->background_width = last_x - s->x + 1;
 30102   else
 30103     {
 30104       s->background_width = s->width;
 30105 #ifdef HAVE_WINDOW_SYSTEM
 30106       if (FRAME_WINDOW_P (s->f)
 30107           && s->hl == DRAW_CURSOR
 30108           && MATRIX_ROW (s->w->current_matrix,
 30109                          s->w->phys_cursor.vpos)->mouse_face_p
 30110           && cursor_in_mouse_face_p (s->w))
 30111         {
 30112           /* Adjust the background width of the glyph string, because
 30113              if the glyph's face has the :box attribute, its
 30114              pixel_width might be different when it's displayed in the
 30115              mouse-face, if that also has the :box attribute.  */
 30116           struct glyph *g = s->first_glyph;
 30117           struct face *regular_face = FACE_FROM_ID (s->f, g->face_id);
 30118           s->background_width +=
 30119             adjust_glyph_width_for_mouse_face (g, s->row, s->w,
 30120                                                regular_face, s->face);
 30121           /* S->width is probably worth adjusting here as well.  */
 30122           s->width = s->background_width;
 30123         }
 30124 #endif
 30125     }
 30126 }
 30127 
 30128 
 30129 /* Return glyph string that shares background with glyph string S and
 30130    whose `background_width' member has been set.  */
 30131 
 30132 static struct glyph_string *
 30133 glyph_string_containing_background_width (struct glyph_string *s)
 30134 {
 30135   if (s->cmp)
 30136     while (s->cmp_from)
 30137       s = s->prev;
 30138 
 30139   return s;
 30140 }
 30141 
 30142 
 30143 /* Compute overhangs and x-positions for glyph string S and its
 30144    predecessors, or successors.  X is the starting x-position for S.
 30145    BACKWARD_P means process predecessors.  */
 30146 
 30147 static void
 30148 compute_overhangs_and_x (struct glyph_string *s, int x, bool backward_p)
 30149 {
 30150   if (backward_p)
 30151     {
 30152       while (s)
 30153         {
 30154           if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
 30155             FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
 30156           if (!s->cmp || s->cmp_to == s->cmp->glyph_len)
 30157             x -= s->width;
 30158           s->x = x;
 30159           s = s->prev;
 30160         }
 30161     }
 30162   else
 30163     {
 30164       while (s)
 30165         {
 30166           if (FRAME_RIF (s->f)->compute_glyph_string_overhangs)
 30167             FRAME_RIF (s->f)->compute_glyph_string_overhangs (s);
 30168           s->x = x;
 30169           if (!s->cmp || s->cmp_to == s->cmp->glyph_len)
 30170             x += s->width;
 30171           s = s->next;
 30172         }
 30173     }
 30174 }
 30175 
 30176 
 30177 
 30178 /* The following macros are only called from draw_glyphs below.
 30179    They reference the following parameters of that function directly:
 30180      `w', `row', `area', and `overlap_p'
 30181    as well as the following local variables:
 30182      `s', `f', and `hdc' (in W32)  */
 30183 
 30184 #ifdef HAVE_NTGUI
 30185 /* On W32, silently add local `hdc' variable to argument list of
 30186    init_glyph_string.  */
 30187 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
 30188   init_glyph_string (s, hdc, char2b, w, row, area, start, hl)
 30189 #else
 30190 #define INIT_GLYPH_STRING(s, char2b, w, row, area, start, hl) \
 30191   init_glyph_string (s, char2b, w, row, area, start, hl)
 30192 #endif
 30193 
 30194 /* Add a glyph string for a stretch glyph to the list of strings
 30195    between HEAD and TAIL.  START is the index of the stretch glyph in
 30196    row area AREA of glyph row ROW.  END is the index of the last glyph
 30197    in that glyph row area.  X is the current output position assigned
 30198    to the new glyph string constructed.  HL overrides that face of the
 30199    glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn.  LAST_X
 30200    is the right-most x-position of the drawing area.  */
 30201 
 30202 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
 30203    and below -- keep them on one line.  */
 30204 #define BUILD_STRETCH_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X)   \
 30205      do                                                                     \
 30206        {                                                                    \
 30207          s = alloca (sizeof *s);                                            \
 30208          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);              \
 30209          START = fill_stretch_glyph_string (s, START, END);                 \
 30210          append_glyph_string (&HEAD, &TAIL, s);                             \
 30211          s->x = (X);                                                        \
 30212        }                                                                    \
 30213      while (false)
 30214 
 30215 
 30216 /* Add a glyph string for an image glyph to the list of strings
 30217    between HEAD and TAIL.  START is the index of the image glyph in
 30218    row area AREA of glyph row ROW.  END is the index of the last glyph
 30219    in that glyph row area.  X is the current output position assigned
 30220    to the new glyph string constructed.  HL overrides that face of the
 30221    glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn.  LAST_X
 30222    is the right-most x-position of the drawing area.  */
 30223 
 30224 #define BUILD_IMAGE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30225      do                                                                 \
 30226        {                                                                \
 30227          s = alloca (sizeof *s);                                        \
 30228          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);          \
 30229          fill_image_glyph_string (s);                                   \
 30230          append_glyph_string (&HEAD, &TAIL, s);                         \
 30231          ++START;                                                       \
 30232          s->x = (X);                                                    \
 30233        }                                                                \
 30234      while (false)
 30235 
 30236 #ifndef HAVE_XWIDGETS
 30237 # define BUILD_XWIDGET_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30238      eassume (false)
 30239 #else
 30240 # define BUILD_XWIDGET_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30241      do                                                                 \
 30242        {                                                                \
 30243          s = alloca (sizeof *s);                                        \
 30244          INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);          \
 30245          fill_xwidget_glyph_string (s);                                 \
 30246          append_glyph_string (&(HEAD), &(TAIL), s);                     \
 30247          ++(START);                                                     \
 30248          s->x = (X);                                                    \
 30249        }                                                                \
 30250      while (false)
 30251 #endif
 30252 
 30253 /* Add a glyph string for a sequence of character glyphs to the list
 30254    of strings between HEAD and TAIL.  START is the index of the first
 30255    glyph in row area AREA of glyph row ROW that is part of the new
 30256    glyph string.  END is the index of the last glyph in that glyph row
 30257    area.  X is the current output position assigned to the new glyph
 30258    string constructed.  HL overrides that face of the glyph; e.g. it
 30259    is DRAW_CURSOR if a cursor has to be drawn.  LAST_X is the
 30260    right-most x-position of the drawing area.  */
 30261 
 30262 #define BUILD_CHAR_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X)    \
 30263      do                                                                    \
 30264        {                                                                   \
 30265          int face_id;                                                      \
 30266          unsigned *char2b;                                         \
 30267                                                                            \
 30268          face_id = (row)->glyphs[area][START].face_id;                     \
 30269                                                                            \
 30270          s = alloca (sizeof *s);                                           \
 30271          SAFE_NALLOCA (char2b, 1, (END) - (START));                        \
 30272          INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);           \
 30273          append_glyph_string (&HEAD, &TAIL, s);                            \
 30274          s->x = (X);                                                       \
 30275          START = fill_glyph_string (s, face_id, START, END, overlaps);     \
 30276        }                                                                   \
 30277      while (false)
 30278 
 30279 
 30280 /* Add a glyph string for a composite sequence to the list of strings
 30281    between HEAD and TAIL.  START is the index of the first glyph in
 30282    row area AREA of glyph row ROW that is part of the new glyph
 30283    string.  END is the index of the last glyph in that glyph row area.
 30284    X is the current output position assigned to the new glyph string
 30285    constructed.  HL overrides that face of the glyph; e.g. it is
 30286    DRAW_CURSOR if a cursor has to be drawn.  LAST_X is the right-most
 30287    x-position of the drawing area.  */
 30288 
 30289 #define BUILD_COMPOSITE_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30290   do {                                                                      \
 30291     int face_id = (row)->glyphs[area][START].face_id;                       \
 30292     struct face *base_face = FACE_FROM_ID (f, face_id);             \
 30293     ptrdiff_t cmp_id = (row)->glyphs[area][START].u.cmp.id;                 \
 30294     struct composition *cmp = composition_table[cmp_id];                    \
 30295     unsigned *char2b;                                                       \
 30296     struct glyph_string *first_s = NULL;                                    \
 30297     int n;                                                                  \
 30298                                                                             \
 30299     SAFE_NALLOCA (char2b, 1, cmp->glyph_len);                               \
 30300                                                                             \
 30301     /* Make glyph_strings for each glyph sequence that is drawable by       \
 30302        the same face, and append them to HEAD/TAIL.  */                     \
 30303     for (n = 0; n < cmp->glyph_len;)                                        \
 30304       {                                                                     \
 30305         s = alloca (sizeof *s);                                             \
 30306         INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);             \
 30307         append_glyph_string (&(HEAD), &(TAIL), s);                          \
 30308         s->cmp = cmp;                                                       \
 30309         s->cmp_from = n;                                                    \
 30310         s->x = (X);                                                         \
 30311         if (n == 0)                                                         \
 30312           first_s = s;                                                      \
 30313         n = fill_composite_glyph_string (s, base_face, overlaps);           \
 30314       }                                                                     \
 30315                                                                             \
 30316     ++START;                                                                \
 30317     s = first_s;                                                            \
 30318   } while (false)
 30319 
 30320 
 30321 /* Add a glyph string for a glyph-string sequence to the list of strings
 30322    between HEAD and TAIL.  */
 30323 
 30324 #define BUILD_GSTRING_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30325   do {                                                                    \
 30326     int face_id;                                                          \
 30327     unsigned *char2b;                                                     \
 30328     Lisp_Object gstring;                                                  \
 30329                                                                           \
 30330     face_id = (row)->glyphs[area][START].face_id;                         \
 30331     gstring = (composition_gstring_from_id                                \
 30332                ((row)->glyphs[area][START].u.cmp.id));                    \
 30333     s = alloca (sizeof *s);                                               \
 30334     SAFE_NALLOCA (char2b, 1, LGSTRING_GLYPH_LEN (gstring));               \
 30335     INIT_GLYPH_STRING (s, char2b, w, row, area, START, HL);               \
 30336     append_glyph_string (&(HEAD), &(TAIL), s);                            \
 30337     s->x = (X);                                                           \
 30338     START = fill_gstring_glyph_string (s, face_id, START, END, overlaps); \
 30339   } while (false)
 30340 
 30341 
 30342 /* Add a glyph string for a sequence of glyphless character's glyphs
 30343    to the list of strings between HEAD and TAIL.  The meanings of
 30344    arguments are the same as those of BUILD_CHAR_GLYPH_STRINGS.  */
 30345 
 30346 #define BUILD_GLYPHLESS_GLYPH_STRING(START, END, HEAD, TAIL, HL, X, LAST_X) \
 30347   do                                                                        \
 30348     {                                                                       \
 30349       int face_id;                                                          \
 30350                                                                             \
 30351       face_id = (row)->glyphs[area][START].face_id;                         \
 30352                                                                             \
 30353       s = alloca (sizeof *s);                                               \
 30354       INIT_GLYPH_STRING (s, NULL, w, row, area, START, HL);                 \
 30355       append_glyph_string (&HEAD, &TAIL, s);                                \
 30356       s->x = (X);                                                           \
 30357       START = fill_glyphless_glyph_string (s, face_id, START, END,          \
 30358                                            overlaps);                       \
 30359     }                                                                       \
 30360   while (false)
 30361 
 30362 
 30363 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
 30364    of AREA of glyph row ROW on window W between indices START and END.
 30365    HL overrides the face for drawing glyph strings, e.g. it is
 30366    DRAW_CURSOR to draw a cursor.  X and LAST_X are start and end
 30367    x-positions of the drawing area.
 30368 
 30369    This is an ugly monster macro construct because we must use alloca
 30370    to allocate glyph strings (because draw_glyphs can be called
 30371    asynchronously).  */
 30372 
 30373 #define BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X)    \
 30374   do                                                                    \
 30375     {                                                                   \
 30376       HEAD = TAIL = NULL;                                               \
 30377       while (START < END)                                               \
 30378         {                                                               \
 30379           struct glyph *first_glyph = (row)->glyphs[area] + START;      \
 30380           switch (first_glyph->type)                                    \
 30381             {                                                           \
 30382             case CHAR_GLYPH:                                            \
 30383               BUILD_CHAR_GLYPH_STRINGS (START, END, HEAD, TAIL,         \
 30384                                         HL, X, LAST_X);                 \
 30385               break;                                                    \
 30386                                                                         \
 30387             case COMPOSITE_GLYPH:                                       \
 30388               if (first_glyph->u.cmp.automatic)                         \
 30389                 BUILD_GSTRING_GLYPH_STRING (START, END, HEAD, TAIL,     \
 30390                                             HL, X, LAST_X);             \
 30391               else                                                      \
 30392                 BUILD_COMPOSITE_GLYPH_STRING (START, END, HEAD, TAIL,   \
 30393                                               HL, X, LAST_X);           \
 30394               break;                                                    \
 30395                                                                         \
 30396             case STRETCH_GLYPH:                                         \
 30397               BUILD_STRETCH_GLYPH_STRING (START, END, HEAD, TAIL,       \
 30398                                           HL, X, LAST_X);               \
 30399               break;                                                    \
 30400                                                                         \
 30401             case IMAGE_GLYPH:                                           \
 30402               BUILD_IMAGE_GLYPH_STRING (START, END, HEAD, TAIL,         \
 30403                                         HL, X, LAST_X);                 \
 30404               break;
 30405 
 30406 #define BUILD_GLYPH_STRINGS_XW(START, END, HEAD, TAIL, HL, X, LAST_X)   \
 30407             case XWIDGET_GLYPH:                                         \
 30408               BUILD_XWIDGET_GLYPH_STRING (START, END, HEAD, TAIL,       \
 30409                                           HL, X, LAST_X);               \
 30410               break;
 30411 
 30412 #define BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X)    \
 30413             case GLYPHLESS_GLYPH:                                       \
 30414               BUILD_GLYPHLESS_GLYPH_STRING (START, END, HEAD, TAIL,     \
 30415                                             HL, X, LAST_X);             \
 30416               break;                                                    \
 30417                                                                         \
 30418             default:                                                    \
 30419               emacs_abort ();                                           \
 30420             }                                                           \
 30421                                                                         \
 30422           if (s)                                                        \
 30423             {                                                           \
 30424               set_glyph_string_background_width (s, START, LAST_X);     \
 30425               (X) += s->width;                                          \
 30426             }                                                           \
 30427         }                                                               \
 30428     } while (false)
 30429 
 30430 
 30431 #define BUILD_GLYPH_STRINGS(START, END, HEAD, TAIL, HL, X, LAST_X)      \
 30432     BUILD_GLYPH_STRINGS_1(START, END, HEAD, TAIL, HL, X, LAST_X)        \
 30433     BUILD_GLYPH_STRINGS_XW(START, END, HEAD, TAIL, HL, X, LAST_X)       \
 30434     BUILD_GLYPH_STRINGS_2(START, END, HEAD, TAIL, HL, X, LAST_X)
 30435 
 30436 
 30437 /* Draw glyphs between START and END in AREA of ROW on window W,
 30438    starting at x-position X.  X is relative to AREA in W.  HL is a
 30439    face-override with the following meaning:
 30440 
 30441    DRAW_NORMAL_TEXT     draw normally
 30442    DRAW_CURSOR          draw in cursor face
 30443    DRAW_MOUSE_FACE      draw in mouse face.
 30444    DRAW_INVERSE_VIDEO   draw in mode line face
 30445    DRAW_IMAGE_SUNKEN    draw an image with a sunken relief around it
 30446    DRAW_IMAGE_RAISED    draw an image with a raised relief around it
 30447 
 30448    If OVERLAPS is non-zero, draw only the foreground of characters and
 30449    clip to the physical height of ROW.  Non-zero value also defines
 30450    the overlapping part to be drawn:
 30451 
 30452    OVERLAPS_PRED                overlap with preceding rows
 30453    OVERLAPS_SUCC                overlap with succeeding rows
 30454    OVERLAPS_BOTH                overlap with both preceding/succeeding rows
 30455    OVERLAPS_ERASED_CURSOR       overlap with erased cursor area
 30456 
 30457    Value is the x-position reached, relative to AREA of W.  */
 30458 
 30459 static int
 30460 draw_glyphs (struct window *w, int x, struct glyph_row *row,
 30461              enum glyph_row_area area, ptrdiff_t start, ptrdiff_t end,
 30462              enum draw_glyphs_face hl, int overlaps)
 30463 {
 30464   struct glyph_string *head, *tail;
 30465   struct glyph_string *s;
 30466   struct glyph_string *clip_head = NULL, *clip_tail = NULL;
 30467   int i, j, x_reached, last_x, area_left = 0;
 30468   struct frame *f = XFRAME (WINDOW_FRAME (w));
 30469 
 30470   ALLOCATE_HDC (hdc, f);
 30471 
 30472   /* Let's rather be paranoid than getting a SEGV.  */
 30473   end = min (end, row->used[area]);
 30474   start = clip_to_bounds (0, start, end);
 30475 
 30476   /* Translate X to frame coordinates.  Set last_x to the right
 30477      end of the drawing area.  */
 30478   if (row->full_width_p)
 30479     {
 30480       /* X is relative to the left edge of W, without scroll bars
 30481          or fringes.  */
 30482       area_left = WINDOW_LEFT_EDGE_X (w);
 30483       last_x = (WINDOW_LEFT_EDGE_X (w) + WINDOW_PIXEL_WIDTH (w)
 30484                 - (row->mode_line_p ? WINDOW_RIGHT_DIVIDER_WIDTH (w) : 0));
 30485     }
 30486   else
 30487     {
 30488       area_left = window_box_left (w, area);
 30489       last_x = area_left + window_box_width (w, area);
 30490     }
 30491   x += area_left;
 30492 
 30493   /* Build a doubly-linked list of glyph_string structures between
 30494      head and tail from what we have to draw.  Note that the macro
 30495      BUILD_GLYPH_STRINGS will modify its start parameter.  That's
 30496      the reason we use a separate variable `i'.  */
 30497   i = start;
 30498   USE_SAFE_ALLOCA;
 30499   BUILD_GLYPH_STRINGS (i, end, head, tail, hl, x, last_x);
 30500   if (tail)
 30501     {
 30502       s = glyph_string_containing_background_width (tail);
 30503       x_reached = s->x + s->background_width;
 30504     }
 30505   else
 30506     x_reached = x;
 30507 
 30508   /* If there are any glyphs with lbearing < 0 or rbearing > width in
 30509      the row, redraw some glyphs in front or following the glyph
 30510      strings built above.  */
 30511   if (head && !overlaps && row->contains_overlapping_glyphs_p)
 30512     {
 30513       struct glyph_string *h, *t;
 30514       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 30515       int mouse_beg_col UNINIT, mouse_end_col UNINIT;
 30516       bool check_mouse_face = false;
 30517       int dummy_x = 0;
 30518 
 30519       /* If mouse highlighting is on, we may need to draw adjacent
 30520          glyphs using mouse-face highlighting.  */
 30521       if (area == TEXT_AREA && row->mouse_face_p
 30522           && hlinfo->mouse_face_beg_row >= 0
 30523           && hlinfo->mouse_face_end_row >= 0)
 30524         {
 30525           ptrdiff_t row_vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
 30526 
 30527           if (row_vpos >= hlinfo->mouse_face_beg_row
 30528               && row_vpos <= hlinfo->mouse_face_end_row)
 30529             {
 30530               check_mouse_face = true;
 30531               mouse_beg_col = (row_vpos == hlinfo->mouse_face_beg_row)
 30532                 ? hlinfo->mouse_face_beg_col : 0;
 30533               mouse_end_col = (row_vpos == hlinfo->mouse_face_end_row)
 30534                 ? hlinfo->mouse_face_end_col
 30535                 : row->used[TEXT_AREA];
 30536             }
 30537         }
 30538 
 30539       /* Compute overhangs for all glyph strings.  */
 30540       if (FRAME_RIF (f)->compute_glyph_string_overhangs)
 30541         for (s = head; s; s = s->next)
 30542           FRAME_RIF (f)->compute_glyph_string_overhangs (s);
 30543 
 30544       /* Prepend glyph strings for glyphs in front of the first glyph
 30545          string that are overwritten because of the first glyph
 30546          string's left overhang.  The background of all strings
 30547          prepended must be drawn because the first glyph string
 30548          draws over it.  */
 30549       i = left_overwritten (head);
 30550       if (i >= 0)
 30551         {
 30552           enum draw_glyphs_face overlap_hl;
 30553 
 30554           /* If this row contains mouse highlighting, attempt to draw
 30555              the overlapped glyphs with the correct highlight.  This
 30556              code fails if the overlap encompasses more than one glyph
 30557              and mouse-highlight spans only some of these glyphs.
 30558              However, making it work perfectly involves a lot more
 30559              code, and I don't know if the pathological case occurs in
 30560              practice, so we'll stick to this for now.  --- cyd  */
 30561           if (check_mouse_face
 30562               && mouse_beg_col < start && mouse_end_col > i)
 30563             overlap_hl = DRAW_MOUSE_FACE;
 30564           else
 30565             overlap_hl = DRAW_NORMAL_TEXT;
 30566 
 30567           if (hl != overlap_hl)
 30568             clip_head = head;
 30569           j = i;
 30570           BUILD_GLYPH_STRINGS (j, start, h, t,
 30571                                overlap_hl, dummy_x, last_x);
 30572           start = i;
 30573           compute_overhangs_and_x (t, head->x, true);
 30574           prepend_glyph_string_lists (&head, &tail, h, t);
 30575           if (clip_head == NULL)
 30576             clip_head = head;
 30577         }
 30578 
 30579       /* Prepend glyph strings for glyphs in front of the first glyph
 30580          string that overwrite that glyph string because of their
 30581          right overhang.  For these strings, only the foreground must
 30582          be drawn, because it draws over the glyph string at `head'.
 30583          The background must not be drawn because this would overwrite
 30584          right overhangs of preceding glyphs for which no glyph
 30585          strings exist.  */
 30586       i = left_overwriting (head);
 30587       if (i >= 0)
 30588         {
 30589           enum draw_glyphs_face overlap_hl;
 30590 
 30591           if (check_mouse_face
 30592               && mouse_beg_col < start && mouse_end_col > i)
 30593             overlap_hl = DRAW_MOUSE_FACE;
 30594           else
 30595             overlap_hl = DRAW_NORMAL_TEXT;
 30596 
 30597           if (hl == overlap_hl || clip_head == NULL)
 30598             clip_head = head;
 30599           BUILD_GLYPH_STRINGS (i, start, h, t,
 30600                                overlap_hl, dummy_x, last_x);
 30601           for (s = h; s; s = s->next)
 30602             s->background_filled_p = true;
 30603           compute_overhangs_and_x (t, head->x, true);
 30604           prepend_glyph_string_lists (&head, &tail, h, t);
 30605         }
 30606 
 30607       /* Append glyphs strings for glyphs following the last glyph
 30608          string tail that are overwritten by tail.  The background of
 30609          these strings has to be drawn because tail's foreground draws
 30610          over it.  */
 30611       i = right_overwritten (tail);
 30612       if (i >= 0)
 30613         {
 30614           enum draw_glyphs_face overlap_hl;
 30615 
 30616           if (check_mouse_face
 30617               && mouse_beg_col < i && mouse_end_col > end)
 30618             overlap_hl = DRAW_MOUSE_FACE;
 30619           else
 30620             overlap_hl = DRAW_NORMAL_TEXT;
 30621 
 30622           if (hl != overlap_hl)
 30623             clip_tail = tail;
 30624           BUILD_GLYPH_STRINGS (end, i, h, t,
 30625                                overlap_hl, x, last_x);
 30626           /* Because BUILD_GLYPH_STRINGS updates the first argument,
 30627              we don't have `end = i;' here.  */
 30628           compute_overhangs_and_x (h, tail->x + tail->width, false);
 30629           append_glyph_string_lists (&head, &tail, h, t);
 30630           if (clip_tail == NULL)
 30631             clip_tail = tail;
 30632         }
 30633 
 30634       /* Append glyph strings for glyphs following the last glyph
 30635          string tail that overwrite tail.  The foreground of such
 30636          glyphs has to be drawn because it writes into the background
 30637          of tail.  The background must not be drawn because it could
 30638          paint over the foreground of following glyphs.  */
 30639       i = right_overwriting (tail);
 30640       if (i >= 0)
 30641         {
 30642           enum draw_glyphs_face overlap_hl;
 30643           if (check_mouse_face
 30644               && mouse_beg_col < i && mouse_end_col > end)
 30645             overlap_hl = DRAW_MOUSE_FACE;
 30646           else
 30647             overlap_hl = DRAW_NORMAL_TEXT;
 30648 
 30649           if (hl == overlap_hl || clip_tail == NULL)
 30650             clip_tail = tail;
 30651           i++;                  /* We must include the Ith glyph.  */
 30652           BUILD_GLYPH_STRINGS (end, i, h, t,
 30653                                overlap_hl, x, last_x);
 30654           for (s = h; s; s = s->next)
 30655             s->background_filled_p = true;
 30656           compute_overhangs_and_x (h, tail->x + tail->width, false);
 30657           append_glyph_string_lists (&head, &tail, h, t);
 30658         }
 30659       tail = glyph_string_containing_background_width (tail);
 30660       if (clip_tail)
 30661         clip_tail = glyph_string_containing_background_width (clip_tail);
 30662       if (clip_head || clip_tail)
 30663         for (s = head; s; s = s->next)
 30664           {
 30665             s->clip_head = clip_head;
 30666             s->clip_tail = clip_tail;
 30667           }
 30668     }
 30669 
 30670   /* Draw all strings.  */
 30671   for (s = head; s; s = s->next)
 30672     FRAME_RIF (f)->draw_glyph_string (s);
 30673 
 30674   /* When focus a sole frame and move horizontally, this clears on_p
 30675      causing a failure to erase prev cursor position. */
 30676   if (area == TEXT_AREA
 30677       && !row->full_width_p
 30678       /* When drawing overlapping rows, only the glyph strings'
 30679          foreground is drawn, which doesn't erase a cursor
 30680          completely. */
 30681       && !overlaps)
 30682     {
 30683       int x0 = clip_head ? clip_head->x : (head ? head->x : x);
 30684       int x1 = (clip_tail ? clip_tail->x + clip_tail->background_width
 30685                 : (tail ? tail->x + tail->background_width : x));
 30686       x0 -= area_left;
 30687       x1 -= area_left;
 30688 
 30689       notice_overwritten_cursor (w, TEXT_AREA, x0, x1,
 30690                                  row->y, MATRIX_ROW_BOTTOM_Y (row));
 30691     }
 30692 
 30693   /* Value is the x-position up to which drawn, relative to AREA of W.
 30694      This doesn't include parts drawn because of overhangs.  */
 30695   if (row->full_width_p)
 30696     x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
 30697   else
 30698     x_reached -= area_left;
 30699 
 30700   RELEASE_HDC (hdc, f);
 30701 
 30702   SAFE_FREE ();
 30703   return x_reached;
 30704 }
 30705 
 30706 /* Find the first glyph in the run of underlined glyphs preceding the
 30707    beginning of glyph string S, and return its font (which could be
 30708    NULL).  This is needed because that font determines the underline
 30709    position and thickness for the entire run of the underlined glyphs.
 30710    This function is called from the draw_glyph_string method of GUI
 30711    frame's redisplay interface (RIF) when it needs to draw in an
 30712    underlined face.  */
 30713 struct font *
 30714 font_for_underline_metrics (struct glyph_string *s)
 30715 {
 30716   struct glyph *g0 = s->row->glyphs[s->area], *g;
 30717 
 30718   for (g = s->first_glyph - 1; g >= g0; g--)
 30719     {
 30720       struct face *prev_face = FACE_FROM_ID (s->f, g->face_id);
 30721       if (!(prev_face && prev_face->underline != FACE_NO_UNDERLINE))
 30722         break;
 30723     }
 30724 
 30725   /* If preceding glyphs are not underlined, use the font of S.  */
 30726   if (g == s->first_glyph - 1)
 30727     return s->font;
 30728   else
 30729     {
 30730       /* Otherwise use the font of the last glyph we saw in the above
 30731          loop whose face had the underline_p flag set.  */
 30732       return FACE_FROM_ID (s->f, g[1].face_id)->font;
 30733     }
 30734 }
 30735 
 30736 /* Expand row matrix if too narrow.  Don't expand if area
 30737    is not present.  */
 30738 
 30739 #define IT_EXPAND_MATRIX_WIDTH(it, area)                \
 30740   {                                                     \
 30741     if (!it->f->fonts_changed                           \
 30742         && (it->glyph_row->glyphs[area]                 \
 30743             < it->glyph_row->glyphs[area + 1]))         \
 30744       {                                                 \
 30745         it->w->ncols_scale_factor++;                    \
 30746         it->f->fonts_changed = true;                    \
 30747       }                                                 \
 30748   }
 30749 
 30750 /* Store one glyph for IT->char_to_display in IT->glyph_row.
 30751    Called from gui_produce_glyphs when IT->glyph_row is non-null.  */
 30752 
 30753 static void
 30754 append_glyph (struct it *it)
 30755 {
 30756   struct glyph *glyph;
 30757   enum glyph_row_area area = it->area;
 30758 
 30759   eassert (it->glyph_row);
 30760   eassert (it->char_to_display != '\n' && it->char_to_display != '\t');
 30761 
 30762   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 30763   if (glyph < it->glyph_row->glyphs[area + 1])
 30764     {
 30765       /* If the glyph row is reversed, we need to prepend the glyph
 30766          rather than append it.  */
 30767       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 30768         {
 30769           struct glyph *g;
 30770 
 30771           /* Make room for the additional glyph.  */
 30772           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
 30773             g[1] = *g;
 30774           glyph = it->glyph_row->glyphs[area];
 30775         }
 30776       glyph->charpos = CHARPOS (it->position);
 30777       glyph->object = it->object;
 30778       if (it->pixel_width > 0)
 30779         {
 30780           eassert (it->pixel_width <= SHRT_MAX);
 30781           glyph->pixel_width = it->pixel_width;
 30782           glyph->padding_p = false;
 30783         }
 30784       else
 30785         {
 30786           /* Assure at least 1-pixel width.  Otherwise, cursor can't
 30787              be displayed correctly.  */
 30788           glyph->pixel_width = 1;
 30789           glyph->padding_p = true;
 30790         }
 30791       glyph->ascent = it->ascent;
 30792       glyph->descent = it->descent;
 30793       glyph->voffset = it->voffset;
 30794       glyph->type = CHAR_GLYPH;
 30795       glyph->avoid_cursor_p = it->avoid_cursor_p;
 30796       glyph->multibyte_p = it->multibyte_p;
 30797       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 30798         {
 30799           /* In R2L rows, the left and the right box edges need to be
 30800              drawn in reverse direction.  */
 30801           glyph->right_box_line_p = it->start_of_box_run_p;
 30802           glyph->left_box_line_p = it->end_of_box_run_p;
 30803         }
 30804       else
 30805         {
 30806           glyph->left_box_line_p = it->start_of_box_run_p;
 30807           glyph->right_box_line_p = it->end_of_box_run_p;
 30808         }
 30809       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
 30810                                       || it->phys_descent > it->descent);
 30811       glyph->glyph_not_available_p = it->glyph_not_available_p;
 30812       glyph->face_id = it->face_id;
 30813       glyph->u.ch = it->char_to_display;
 30814       glyph->slice.img = null_glyph_slice;
 30815       glyph->font_type = FONT_TYPE_UNKNOWN;
 30816       if (it->bidi_p)
 30817         {
 30818           glyph->resolved_level = it->bidi_it.resolved_level;
 30819           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 30820           glyph->bidi_type = it->bidi_it.type;
 30821         }
 30822       else
 30823         {
 30824           glyph->resolved_level = 0;
 30825           glyph->bidi_type = UNKNOWN_BT;
 30826         }
 30827       ++it->glyph_row->used[area];
 30828     }
 30829   else
 30830     IT_EXPAND_MATRIX_WIDTH (it, area);
 30831 }
 30832 
 30833 /* Store one glyph for the composition IT->cmp_it.id in IT->glyph_row.
 30834    Called from gui_produce_glyphs when IT->glyph_row is non-null.  */
 30835 
 30836 static void
 30837 append_composite_glyph (struct it *it)
 30838 {
 30839   struct glyph *glyph;
 30840   enum glyph_row_area area = it->area;
 30841 
 30842   eassert (it->glyph_row);
 30843 
 30844   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 30845   if (glyph < it->glyph_row->glyphs[area + 1])
 30846     {
 30847       /* If the glyph row is reversed, we need to prepend the glyph
 30848          rather than append it.  */
 30849       if (it->glyph_row->reversed_p && it->area == TEXT_AREA)
 30850         {
 30851           struct glyph *g;
 30852 
 30853           /* Make room for the new glyph.  */
 30854           for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
 30855             g[1] = *g;
 30856           glyph = it->glyph_row->glyphs[it->area];
 30857         }
 30858       glyph->charpos = it->cmp_it.charpos;
 30859       glyph->object = it->object;
 30860       eassert (it->pixel_width <= SHRT_MAX);
 30861       glyph->pixel_width = it->pixel_width;
 30862       glyph->ascent = it->ascent;
 30863       glyph->descent = it->descent;
 30864       glyph->voffset = it->voffset;
 30865       glyph->type = COMPOSITE_GLYPH;
 30866       if (it->cmp_it.ch < 0)
 30867         {
 30868           glyph->u.cmp.automatic = false;
 30869           glyph->u.cmp.id = it->cmp_it.id;
 30870           glyph->slice.cmp.from = glyph->slice.cmp.to = 0;
 30871         }
 30872       else
 30873         {
 30874           glyph->u.cmp.automatic = true;
 30875           glyph->u.cmp.id = it->cmp_it.id;
 30876           glyph->slice.cmp.from = it->cmp_it.from;
 30877           glyph->slice.cmp.to = it->cmp_it.to - 1;
 30878         }
 30879       glyph->avoid_cursor_p = it->avoid_cursor_p;
 30880       glyph->multibyte_p = it->multibyte_p;
 30881       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 30882         {
 30883           /* In R2L rows, the left and the right box edges need to be
 30884              drawn in reverse direction.  */
 30885           glyph->right_box_line_p = it->start_of_box_run_p;
 30886           glyph->left_box_line_p = it->end_of_box_run_p;
 30887         }
 30888       else
 30889         {
 30890           glyph->left_box_line_p = it->start_of_box_run_p;
 30891           glyph->right_box_line_p = it->end_of_box_run_p;
 30892         }
 30893       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
 30894                                       || it->phys_descent > it->descent);
 30895       glyph->padding_p = false;
 30896       glyph->glyph_not_available_p = it->glyph_not_available_p;
 30897       glyph->face_id = it->face_id;
 30898       glyph->font_type = FONT_TYPE_UNKNOWN;
 30899       if (it->bidi_p)
 30900         {
 30901           glyph->resolved_level = it->bidi_it.resolved_level;
 30902           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 30903           glyph->bidi_type = it->bidi_it.type;
 30904         }
 30905       ++it->glyph_row->used[area];
 30906     }
 30907   else
 30908     IT_EXPAND_MATRIX_WIDTH (it, area);
 30909 }
 30910 
 30911 
 30912 /* Change IT->ascent and IT->height according to the setting of
 30913    IT->voffset.  */
 30914 
 30915 static void
 30916 take_vertical_position_into_account (struct it *it)
 30917 {
 30918   if (it->voffset)
 30919     {
 30920       if (it->voffset < 0)
 30921         /* Increase the ascent so that we can display the text higher
 30922            in the line.  */
 30923         it->ascent -= it->voffset;
 30924       else
 30925         /* Increase the descent so that we can display the text lower
 30926            in the line.  */
 30927         it->descent += it->voffset;
 30928     }
 30929 }
 30930 
 30931 
 30932 /* Produce glyphs/get display metrics for the image IT is loaded with.
 30933    See the description of struct display_iterator in dispextern.h for
 30934    an overview of struct display_iterator.  */
 30935 
 30936 static void
 30937 produce_image_glyph (struct it *it)
 30938 {
 30939   struct image *img;
 30940   struct face *face;
 30941   int glyph_ascent, crop;
 30942   struct glyph_slice slice;
 30943 
 30944   eassert (it->what == IT_IMAGE);
 30945 
 30946   face = FACE_FROM_ID (it->f, it->face_id);
 30947   /* Make sure X resources of the face is loaded.  */
 30948   prepare_face_for_display (it->f, face);
 30949 
 30950   if (it->image_id < 0)
 30951     {
 30952       /* Fringe bitmap.  */
 30953       it->ascent = it->phys_ascent = 0;
 30954       it->descent = it->phys_descent = 0;
 30955       it->pixel_width = 0;
 30956       it->nglyphs = 0;
 30957       return;
 30958     }
 30959 
 30960   img = IMAGE_FROM_ID (it->f, it->image_id);
 30961   /* Make sure X resources of the image is loaded.  */
 30962   prepare_image_for_display (it->f, img);
 30963 
 30964   slice.x = slice.y = 0;
 30965   slice.width = img->width;
 30966   slice.height = img->height;
 30967 
 30968   if (FIXNUMP (it->slice.x))
 30969     slice.x = XFIXNUM (it->slice.x);
 30970   else if (FLOATP (it->slice.x))
 30971     slice.x = XFLOAT_DATA (it->slice.x) * img->width;
 30972 
 30973   if (FIXNUMP (it->slice.y))
 30974     slice.y = XFIXNUM (it->slice.y);
 30975   else if (FLOATP (it->slice.y))
 30976     slice.y = XFLOAT_DATA (it->slice.y) * img->height;
 30977 
 30978   if (FIXNUMP (it->slice.width))
 30979     slice.width = XFIXNUM (it->slice.width);
 30980   else if (FLOATP (it->slice.width))
 30981     slice.width = XFLOAT_DATA (it->slice.width) * img->width;
 30982 
 30983   if (FIXNUMP (it->slice.height))
 30984     slice.height = XFIXNUM (it->slice.height);
 30985   else if (FLOATP (it->slice.height))
 30986     slice.height = XFLOAT_DATA (it->slice.height) * img->height;
 30987 
 30988   if (slice.x >= img->width)
 30989     slice.x = img->width;
 30990   if (slice.y >= img->height)
 30991     slice.y = img->height;
 30992   if (slice.x + slice.width >= img->width)
 30993     slice.width = img->width - slice.x;
 30994   if (slice.y + slice.height > img->height)
 30995     slice.height = img->height - slice.y;
 30996 
 30997   if (slice.width == 0 || slice.height == 0)
 30998     return;
 30999 
 31000   it->ascent = it->phys_ascent = glyph_ascent = image_ascent (img, face, &slice);
 31001 
 31002   it->descent = slice.height - glyph_ascent;
 31003   if (slice.y == 0)
 31004     it->descent += img->vmargin;
 31005   if (slice.y + slice.height == img->height)
 31006     it->descent += img->vmargin;
 31007   it->phys_descent = it->descent;
 31008 
 31009   it->pixel_width = slice.width;
 31010   if (slice.x == 0)
 31011     it->pixel_width += img->hmargin;
 31012   if (slice.x + slice.width == img->width)
 31013     it->pixel_width += img->hmargin;
 31014 
 31015   /* It's quite possible for images to have an ascent greater than
 31016      their height, so don't get confused in that case.  */
 31017   if (it->descent < 0)
 31018     it->descent = 0;
 31019 
 31020   it->nglyphs = 1;
 31021 
 31022   if (face->box != FACE_NO_BOX)
 31023     {
 31024       /* If you change the logic here, please change it in
 31025          get_cursor_offset_for_mouse_face as well. */
 31026       if (face->box_horizontal_line_width > 0)
 31027         {
 31028           if (slice.y == 0)
 31029             it->ascent += face->box_horizontal_line_width;
 31030           if (slice.y + slice.height == img->height)
 31031             it->descent += face->box_horizontal_line_width;
 31032         }
 31033 
 31034       if (face->box_vertical_line_width > 0)
 31035         {
 31036           if (it->start_of_box_run_p && slice.x == 0)
 31037             it->pixel_width += face->box_vertical_line_width;
 31038           if (it->end_of_box_run_p && slice.x + slice.width == img->width)
 31039             it->pixel_width += face->box_vertical_line_width;
 31040         }
 31041     }
 31042 
 31043   take_vertical_position_into_account (it);
 31044 
 31045   /* Automatically crop wide image glyphs at right edge so we can
 31046      draw the cursor on same display row.  */
 31047   if ((crop = it->pixel_width - (it->last_visible_x - it->current_x), crop > 0)
 31048       && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
 31049     {
 31050       it->pixel_width -= crop;
 31051       slice.width -= crop;
 31052     }
 31053 
 31054   if (it->glyph_row)
 31055     {
 31056       struct glyph *glyph;
 31057       enum glyph_row_area area = it->area;
 31058 
 31059       glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31060       if (it->glyph_row->reversed_p)
 31061         {
 31062           struct glyph *g;
 31063 
 31064           /* Make room for the new glyph.  */
 31065           for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
 31066             g[1] = *g;
 31067           glyph = it->glyph_row->glyphs[it->area];
 31068         }
 31069       if (glyph < it->glyph_row->glyphs[area + 1])
 31070         {
 31071           glyph->charpos = CHARPOS (it->position);
 31072           glyph->object = it->object;
 31073           glyph->pixel_width = clip_to_bounds (-1, it->pixel_width, SHRT_MAX);
 31074           glyph->ascent = glyph_ascent;
 31075           glyph->descent = it->descent;
 31076           glyph->voffset = it->voffset;
 31077           glyph->type = IMAGE_GLYPH;
 31078           glyph->avoid_cursor_p = it->avoid_cursor_p;
 31079           glyph->multibyte_p = it->multibyte_p;
 31080           if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31081             {
 31082               /* In R2L rows, the left and the right box edges need to be
 31083                  drawn in reverse direction.  */
 31084               glyph->right_box_line_p = it->start_of_box_run_p;
 31085               glyph->left_box_line_p = it->end_of_box_run_p;
 31086             }
 31087           else
 31088             {
 31089               glyph->left_box_line_p = it->start_of_box_run_p;
 31090               glyph->right_box_line_p = it->end_of_box_run_p;
 31091             }
 31092           glyph->overlaps_vertically_p = false;
 31093           glyph->padding_p = false;
 31094           glyph->glyph_not_available_p = false;
 31095           glyph->face_id = it->face_id;
 31096           glyph->u.img_id = img->id;
 31097           glyph->slice.img = slice;
 31098           glyph->font_type = FONT_TYPE_UNKNOWN;
 31099           if (it->bidi_p)
 31100             {
 31101               glyph->resolved_level = it->bidi_it.resolved_level;
 31102               eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31103               glyph->bidi_type = it->bidi_it.type;
 31104             }
 31105           ++it->glyph_row->used[area];
 31106         }
 31107       else
 31108         IT_EXPAND_MATRIX_WIDTH (it, area);
 31109     }
 31110 }
 31111 
 31112 static void
 31113 produce_xwidget_glyph (struct it *it)
 31114 {
 31115 #ifdef HAVE_XWIDGETS
 31116   struct xwidget *xw;
 31117   int glyph_ascent, crop;
 31118   eassert (it->what == IT_XWIDGET);
 31119 
 31120   struct face *face = FACE_FROM_ID (it->f, it->face_id);
 31121   /* Make sure X resources of the face is loaded.  */
 31122   prepare_face_for_display (it->f, face);
 31123 
 31124   xw = it->xwidget;
 31125   it->ascent = it->phys_ascent = glyph_ascent = xw->height/2;
 31126   it->descent = xw->height/2;
 31127   it->phys_descent = it->descent;
 31128   it->pixel_width = xw->width;
 31129   /* It's quite possible for images to have an ascent greater than
 31130      their height, so don't get confused in that case.  */
 31131   if (it->descent < 0)
 31132     it->descent = 0;
 31133 
 31134   it->nglyphs = 1;
 31135 
 31136   if (face->box != FACE_NO_BOX)
 31137     {
 31138       if (face->box_horizontal_line_width > 0)
 31139         {
 31140           it->ascent += face->box_horizontal_line_width;
 31141           it->descent += face->box_horizontal_line_width;
 31142         }
 31143 
 31144       if (face->box_vertical_line_width > 0)
 31145         {
 31146           if (it->start_of_box_run_p)
 31147             it->pixel_width += face->box_vertical_line_width;
 31148           it->pixel_width += face->box_vertical_line_width;
 31149         }
 31150     }
 31151 
 31152   take_vertical_position_into_account (it);
 31153 
 31154   /* Automatically crop wide image glyphs at right edge so we can
 31155      draw the cursor on same display row.  */
 31156   crop = it->pixel_width - (it->last_visible_x - it->current_x);
 31157   if (crop > 0 && (it->hpos == 0 || it->pixel_width > it->last_visible_x / 4))
 31158     it->pixel_width -= crop;
 31159 
 31160   if (it->glyph_row)
 31161     {
 31162       enum glyph_row_area area = it->area;
 31163       struct glyph *glyph
 31164         = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31165 
 31166       if (it->glyph_row->reversed_p)
 31167         {
 31168           struct glyph *g;
 31169 
 31170           /* Make room for the new glyph.  */
 31171           for (g = glyph - 1; g >= it->glyph_row->glyphs[it->area]; g--)
 31172             g[1] = *g;
 31173           glyph = it->glyph_row->glyphs[it->area];
 31174         }
 31175       if (glyph < it->glyph_row->glyphs[area + 1])
 31176         {
 31177           glyph->charpos = CHARPOS (it->position);
 31178           glyph->object = it->object;
 31179           glyph->pixel_width = clip_to_bounds (-1, it->pixel_width, SHRT_MAX);
 31180           glyph->ascent = glyph_ascent;
 31181           glyph->descent = it->descent;
 31182           glyph->voffset = it->voffset;
 31183           glyph->type = XWIDGET_GLYPH;
 31184           glyph->avoid_cursor_p = it->avoid_cursor_p;
 31185           glyph->multibyte_p = it->multibyte_p;
 31186           if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31187             {
 31188               /* In R2L rows, the left and the right box edges need to be
 31189                  drawn in reverse direction.  */
 31190               glyph->right_box_line_p = it->start_of_box_run_p;
 31191               glyph->left_box_line_p = it->end_of_box_run_p;
 31192             }
 31193           else
 31194             {
 31195               glyph->left_box_line_p = it->start_of_box_run_p;
 31196               glyph->right_box_line_p = it->end_of_box_run_p;
 31197             }
 31198           glyph->overlaps_vertically_p = 0;
 31199           glyph->padding_p = 0;
 31200           glyph->glyph_not_available_p = 0;
 31201           glyph->face_id = it->face_id;
 31202           glyph->u.xwidget = it->xwidget->xwidget_id;
 31203           glyph->font_type = FONT_TYPE_UNKNOWN;
 31204           if (it->bidi_p)
 31205             {
 31206               glyph->resolved_level = it->bidi_it.resolved_level;
 31207               eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31208               glyph->bidi_type = it->bidi_it.type;
 31209             }
 31210           ++it->glyph_row->used[area];
 31211         }
 31212       else
 31213         IT_EXPAND_MATRIX_WIDTH (it, area);
 31214     }
 31215 #endif
 31216 }
 31217 
 31218 /* Append a stretch glyph to IT->glyph_row.  OBJECT is the source
 31219    of the glyph, WIDTH and HEIGHT are the width and height of the
 31220    stretch.  ASCENT is the ascent of the glyph (0 <= ASCENT <= HEIGHT).  */
 31221 
 31222 static void
 31223 append_stretch_glyph (struct it *it, Lisp_Object object,
 31224                       int width, int height, int ascent)
 31225 {
 31226   struct glyph *glyph;
 31227   enum glyph_row_area area = it->area;
 31228 
 31229   eassert (ascent >= 0 && ascent <= height);
 31230 
 31231   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31232   if (glyph < it->glyph_row->glyphs[area + 1])
 31233     {
 31234       /* If the glyph row is reversed, we need to prepend the glyph
 31235          rather than append it.  */
 31236       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31237         {
 31238           struct glyph *g;
 31239 
 31240           /* Make room for the additional glyph.  */
 31241           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
 31242             g[1] = *g;
 31243           glyph = it->glyph_row->glyphs[area];
 31244 
 31245           /* Decrease the width of the first glyph of the row that
 31246              begins before first_visible_x (e.g., due to hscroll).
 31247              This is so the overall width of the row becomes smaller
 31248              by the scroll amount, and the stretch glyph appended by
 31249              extend_face_to_end_of_line will be wider, to shift the
 31250              row glyphs to the right.  (In L2R rows, the corresponding
 31251              left-shift effect is accomplished by setting row->x to a
 31252              negative value, which won't work with R2L rows.)
 31253 
 31254              This must leave us with a positive value of WIDTH, since
 31255              otherwise the call to move_it_in_display_line_to at the
 31256              beginning of display_line would have got past the entire
 31257              first glyph, and then it->current_x would have been
 31258              greater or equal to it->first_visible_x.  */
 31259           if (it->current_x < it->first_visible_x)
 31260             width -= it->first_visible_x - it->current_x;
 31261           eassert (width > 0);
 31262         }
 31263       glyph->charpos = CHARPOS (it->position);
 31264       glyph->object = object;
 31265       /* FIXME: It would be better to use TYPE_MAX here, but
 31266          __typeof__ is not portable enough...  */
 31267       glyph->pixel_width = clip_to_bounds (-1, width, SHRT_MAX);
 31268       glyph->ascent = ascent;
 31269       glyph->descent = height - ascent;
 31270       glyph->voffset = it->voffset;
 31271       glyph->type = STRETCH_GLYPH;
 31272       glyph->avoid_cursor_p = it->avoid_cursor_p;
 31273       glyph->multibyte_p = it->multibyte_p;
 31274       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31275         {
 31276           /* In R2L rows, the left and the right box edges need to be
 31277              drawn in reverse direction.  */
 31278           glyph->right_box_line_p = it->start_of_box_run_p;
 31279           glyph->left_box_line_p = it->end_of_box_run_p;
 31280         }
 31281       else
 31282         {
 31283           glyph->left_box_line_p = it->start_of_box_run_p;
 31284           glyph->right_box_line_p = it->end_of_box_run_p;
 31285         }
 31286       glyph->overlaps_vertically_p = false;
 31287       glyph->padding_p = false;
 31288       glyph->glyph_not_available_p = false;
 31289       glyph->face_id = it->face_id;
 31290       glyph->u.stretch.ascent = ascent;
 31291       glyph->u.stretch.height = height;
 31292       glyph->slice.img = null_glyph_slice;
 31293       glyph->font_type = FONT_TYPE_UNKNOWN;
 31294       if (it->bidi_p)
 31295         {
 31296           glyph->resolved_level = it->bidi_it.resolved_level;
 31297           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31298           glyph->bidi_type = it->bidi_it.type;
 31299         }
 31300       else
 31301         {
 31302           glyph->resolved_level = 0;
 31303           glyph->bidi_type = UNKNOWN_BT;
 31304         }
 31305       ++it->glyph_row->used[area];
 31306     }
 31307   else
 31308     IT_EXPAND_MATRIX_WIDTH (it, area);
 31309 }
 31310 
 31311 #endif  /* HAVE_WINDOW_SYSTEM */
 31312 
 31313 /* Produce a stretch glyph for iterator IT.  IT->object is the value
 31314    of the display property.  The value must be a list of the form
 31315    `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
 31316    being recognized:
 31317 
 31318    1. `:width WIDTH' specifies that the space should be WIDTH *
 31319    canonical char width wide.  WIDTH may be an integer or floating
 31320    point number.
 31321 
 31322    2. `:relative-width FACTOR' specifies that the width of the stretch
 31323    should be computed from the width of the first character having the
 31324    `display' property, and should be FACTOR times that width.
 31325 
 31326    3. `:align-to HPOS' specifies that the space should be wide enough
 31327    to reach HPOS, a value in canonical character units.
 31328 
 31329    Exactly one of the above pairs must be present.
 31330 
 31331    4. `:height HEIGHT' specifies that the height of the stretch produced
 31332    should be HEIGHT, measured in canonical character units.
 31333 
 31334    5. `:relative-height FACTOR' specifies that the height of the
 31335    stretch should be FACTOR times the height of the characters having
 31336    the display property.
 31337 
 31338    Either none or exactly one of 4 or 5 must be present.
 31339 
 31340    6. `:ascent ASCENT'  specifies that ASCENT percent of the height
 31341    of the stretch should be used for the ascent of the stretch.
 31342    ASCENT must be in the range 0 <= ASCENT <= 100.  */
 31343 
 31344 void
 31345 produce_stretch_glyph (struct it *it)
 31346 {
 31347   /* (space :width WIDTH :height HEIGHT ...)  */
 31348   Lisp_Object prop, plist;
 31349   int width = 0, height = 0, align_to = -1;
 31350   bool zero_width_ok_p = false;
 31351   double tem;
 31352   struct font *font = NULL;
 31353 
 31354 #ifdef HAVE_WINDOW_SYSTEM
 31355   int ascent = 0;
 31356   bool zero_height_ok_p = false;
 31357   struct face *face = NULL;     /* shut up GCC's -Wmaybe-uninitialized */
 31358 
 31359   if (FRAME_WINDOW_P (it->f))
 31360     {
 31361       face = FACE_FROM_ID (it->f, it->face_id);
 31362       font = face->font ? face->font : FRAME_FONT (it->f);
 31363       prepare_face_for_display (it->f, face);
 31364     }
 31365 #endif
 31366 
 31367   /* List should start with `space'.  */
 31368   eassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
 31369   plist = XCDR (it->object);
 31370 
 31371   /* Compute the width of the stretch.  */
 31372   if ((prop = plist_get (plist, QCwidth), !NILP (prop))
 31373       && calc_pixel_width_or_height (&tem, it, prop, font, true, NULL))
 31374     {
 31375       /* Absolute width `:width WIDTH' specified and valid.  */
 31376       zero_width_ok_p = true;
 31377       width = (int)tem;
 31378     }
 31379   else if (prop = plist_get (plist, QCrelative_width), NUMVAL (prop) > 0)
 31380     {
 31381       /* Relative width `:relative-width FACTOR' specified and valid.
 31382          Compute the width of the characters having this `display'
 31383          property.  */
 31384       struct it it2;
 31385       Lisp_Object object =
 31386         it->sp > 0 ? it->stack[it->sp - 1].string : it->string;
 31387       unsigned char *p = (STRINGP (object)
 31388                           ? SDATA (object) + IT_STRING_BYTEPOS (*it)
 31389                           : BYTE_POS_ADDR (IT_BYTEPOS (*it)));
 31390       bool multibyte_p =
 31391         STRINGP (object) ? STRING_MULTIBYTE (object) : it->multibyte_p;
 31392 
 31393       it2 = *it;
 31394       if (multibyte_p)
 31395         {
 31396           it2.c = it2.char_to_display = string_char_and_length (p, &it2.len);
 31397 #ifdef HAVE_WINDOW_SYSTEM
 31398           if (FRAME_WINDOW_P (it->f) && ! ASCII_CHAR_P (it2.c))
 31399             it2.face_id = FACE_FOR_CHAR (it->f, face, it2.c,
 31400                                          IT_CHARPOS (*it),
 31401                                          STRINGP (object)? object : Qnil);
 31402 #endif
 31403         }
 31404       else
 31405         {
 31406           it2.c = it2.char_to_display = *p, it2.len = 1;
 31407           if (! ASCII_CHAR_P (it2.c))
 31408             it2.char_to_display = BYTE8_TO_CHAR (it2.c);
 31409         }
 31410 
 31411       it2.glyph_row = NULL;
 31412       it2.what = IT_CHARACTER;
 31413       PRODUCE_GLYPHS (&it2);
 31414       width = NUMVAL (prop) * it2.pixel_width;
 31415     }
 31416   else if ((prop = plist_get (plist, QCalign_to), !NILP (prop))
 31417            && calc_pixel_width_or_height (&tem, it, prop, font, true,
 31418                                           &align_to))
 31419     {
 31420       int x = it->current_x + it->continuation_lines_width;
 31421       int x0 = x;
 31422       /* Adjust for line numbers, if needed.   */
 31423       if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 31424         {
 31425           x -= it->lnum_pixel_width;
 31426           /* Restore the original width, if required.  */
 31427           if (x + it->stretch_adjust >= it->first_visible_x)
 31428             x += it->stretch_adjust;
 31429         }
 31430 
 31431       if (it->glyph_row == NULL || !it->glyph_row->mode_line_p)
 31432         align_to = (align_to < 0
 31433                     ? 0
 31434                     : align_to - window_box_left_offset (it->w, TEXT_AREA));
 31435       else if (align_to < 0)
 31436         align_to = window_box_left_offset (it->w, TEXT_AREA);
 31437       width = max (0, (int)tem + align_to - x);
 31438 
 31439       int next_x = x + width;
 31440       if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 31441         {
 31442           /* If the line is hscrolled, and the stretch starts before
 31443              the first visible pixel, simulate negative row->x.  */
 31444           if (x < it->first_visible_x)
 31445             {
 31446               next_x -= it->first_visible_x - x;
 31447               it->stretch_adjust = it->first_visible_x - x;
 31448             }
 31449           else
 31450             next_x -= it->stretch_adjust;
 31451         }
 31452       width = next_x - x0;
 31453       zero_width_ok_p = true;
 31454     }
 31455   else
 31456     /* Nothing specified -> width defaults to canonical char width.  */
 31457     width = FRAME_COLUMN_WIDTH (it->f);
 31458 
 31459   if (width <= 0 && (width < 0 || !zero_width_ok_p))
 31460     width = 1;
 31461 
 31462 #ifdef HAVE_WINDOW_SYSTEM
 31463   /* Compute height.  */
 31464   if (FRAME_WINDOW_P (it->f))
 31465     {
 31466       int default_height = normal_char_height (font, ' ');
 31467 
 31468       if ((prop = plist_get (plist, QCheight), !NILP (prop))
 31469           && calc_pixel_width_or_height (&tem, it, prop, font, false, NULL))
 31470         {
 31471           height = (int)tem;
 31472           zero_height_ok_p = true;
 31473         }
 31474       else if (prop = plist_get (plist, QCrelative_height),
 31475                NUMVAL (prop) > 0)
 31476         height = default_height * NUMVAL (prop);
 31477       else
 31478         height = default_height;
 31479 
 31480       if (height <= 0 && (height < 0 || !zero_height_ok_p))
 31481         height = 1;
 31482 
 31483       /* Compute percentage of height used for ascent.  If
 31484          `:ascent ASCENT' is present and valid, use that.  Otherwise,
 31485          derive the ascent from the font in use.  */
 31486       if (prop = plist_get (plist, QCascent),
 31487           NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
 31488         ascent = height * NUMVAL (prop) / 100.0;
 31489       else if (!NILP (prop)
 31490                && calc_pixel_width_or_height (&tem, it, prop, font, false, 0))
 31491         ascent = min (max (0, (int)tem), height);
 31492       else
 31493         ascent = (height * FONT_BASE (font)) / FONT_HEIGHT (font);
 31494     }
 31495   else
 31496 #endif  /* HAVE_WINDOW_SYSTEM */
 31497     height = 1;
 31498 
 31499   if (width > 0
 31500       && it->area == TEXT_AREA && it->line_wrap != TRUNCATE
 31501       && it->current_x + width > it->last_visible_x)
 31502     {
 31503       width = it->last_visible_x - it->current_x;
 31504 #ifdef HAVE_WINDOW_SYSTEM
 31505       /* Subtract one more pixel from the stretch width, but only on
 31506          GUI frames, since on a TTY each glyph is one "pixel" wide.  */
 31507       width -= FRAME_WINDOW_P (it->f);
 31508 #endif
 31509     }
 31510 
 31511   if (width > 0 && height > 0 && it->glyph_row)
 31512     {
 31513       Lisp_Object o_object = it->object;
 31514       Lisp_Object object =
 31515         it->sp > 0 ? it->stack[it->sp - 1].string : it->string;
 31516       int n = width;
 31517 
 31518       if (!STRINGP (object))
 31519         object = it->w->contents;
 31520 #ifdef HAVE_WINDOW_SYSTEM
 31521       if (FRAME_WINDOW_P (it->f))
 31522         append_stretch_glyph (it, object, width, height, ascent);
 31523       else
 31524 #endif
 31525         {
 31526           it->object = object;
 31527           it->char_to_display = ' ';
 31528           it->pixel_width = it->len = 1;
 31529           while (n--)
 31530             tty_append_glyph (it);
 31531           it->object = o_object;
 31532         }
 31533     }
 31534 
 31535   it->pixel_width = width;
 31536 #ifdef HAVE_WINDOW_SYSTEM
 31537   if (FRAME_WINDOW_P (it->f))
 31538     {
 31539       it->ascent = it->phys_ascent = ascent;
 31540       it->descent = it->phys_descent = height - it->ascent;
 31541       it->nglyphs = width > 0 && height > 0;
 31542       take_vertical_position_into_account (it);
 31543     }
 31544   else
 31545 #endif
 31546     it->nglyphs = width;
 31547 }
 31548 
 31549 /* Get information about special display element WHAT in an
 31550    environment described by IT.  WHAT is one of IT_TRUNCATION or
 31551    IT_CONTINUATION.  Maybe produce glyphs for WHAT if IT has a
 31552    non-null glyph_row member.  This function ensures that fields like
 31553    face_id, c, len of IT are left untouched.  */
 31554 
 31555 static void
 31556 produce_special_glyphs (struct it *it, enum display_element_type what)
 31557 {
 31558   struct it temp_it;
 31559   Lisp_Object gc;
 31560   GLYPH glyph;
 31561 
 31562   temp_it = *it;
 31563   temp_it.object = Qnil;
 31564   memset (&temp_it.current, 0, sizeof temp_it.current);
 31565 
 31566   if (what == IT_CONTINUATION)
 31567     {
 31568       /* Continuation glyph.  For R2L lines, we mirror it by hand.  */
 31569       if (it->bidi_it.paragraph_dir == R2L)
 31570         SET_GLYPH_FROM_CHAR (glyph, '/');
 31571       else
 31572         SET_GLYPH_FROM_CHAR (glyph, '\\');
 31573       if (it->dp
 31574           && (gc = DISP_CONTINUE_GLYPH (it->dp), GLYPH_CODE_P (gc)))
 31575         {
 31576           /* FIXME: Should we mirror GC for R2L lines?  */
 31577           SET_GLYPH_FROM_GLYPH_CODE (glyph, gc);
 31578           spec_glyph_lookup_face (XWINDOW (it->window), &glyph);
 31579         }
 31580     }
 31581   else if (what == IT_TRUNCATION)
 31582     {
 31583       /* Truncation glyph.  */
 31584       SET_GLYPH_FROM_CHAR (glyph, '$');
 31585       if (it->dp
 31586           && (gc = DISP_TRUNC_GLYPH (it->dp), GLYPH_CODE_P (gc)))
 31587         {
 31588           /* FIXME: Should we mirror GC for R2L lines?  */
 31589           SET_GLYPH_FROM_GLYPH_CODE (glyph, gc);
 31590           spec_glyph_lookup_face (XWINDOW (it->window), &glyph);
 31591         }
 31592     }
 31593   else
 31594     emacs_abort ();
 31595 
 31596 #ifdef HAVE_WINDOW_SYSTEM
 31597   /* On a GUI frame, when the right fringe (left fringe for R2L rows)
 31598      is turned off, we precede the truncation/continuation glyphs by a
 31599      stretch glyph whose width is computed such that these special
 31600      glyphs are aligned at the window margin, even when very different
 31601      fonts are used in different glyph rows.  */
 31602   if (FRAME_WINDOW_P (temp_it.f)
 31603       /* init_iterator calls this with it->glyph_row == NULL, and it
 31604          wants only the pixel width of the truncation/continuation
 31605          glyphs.  */
 31606       && temp_it.glyph_row
 31607       /* insert_left_trunc_glyphs calls us at the beginning of the
 31608          row, and it has its own calculation of the stretch glyph
 31609          width.  */
 31610       && temp_it.glyph_row->used[TEXT_AREA] > 0
 31611       && (temp_it.glyph_row->reversed_p
 31612           ? WINDOW_LEFT_FRINGE_WIDTH (temp_it.w)
 31613           : WINDOW_RIGHT_FRINGE_WIDTH (temp_it.w)) == 0)
 31614     {
 31615       int stretch_width = temp_it.last_visible_x - temp_it.current_x;
 31616 
 31617       if (stretch_width > 0)
 31618         {
 31619           struct face *face = FACE_FROM_ID (temp_it.f, temp_it.face_id);
 31620           struct font *font =
 31621             face->font ? face->font : FRAME_FONT (temp_it.f);
 31622           int stretch_ascent =
 31623             (((temp_it.ascent + temp_it.descent)
 31624               * FONT_BASE (font)) / FONT_HEIGHT (font));
 31625 
 31626           append_stretch_glyph (&temp_it, Qnil, stretch_width,
 31627                                 temp_it.ascent + temp_it.descent,
 31628                                 stretch_ascent);
 31629         }
 31630     }
 31631 #endif
 31632 
 31633   temp_it.dp = NULL;
 31634   temp_it.what = IT_CHARACTER;
 31635   temp_it.c = temp_it.char_to_display = GLYPH_CHAR (glyph);
 31636   temp_it.face_id = GLYPH_FACE (glyph);
 31637   temp_it.len = CHAR_BYTES (temp_it.c);
 31638 
 31639   PRODUCE_GLYPHS (&temp_it);
 31640   it->pixel_width = temp_it.pixel_width;
 31641   it->nglyphs = temp_it.nglyphs;
 31642 }
 31643 
 31644 /* Produce padding glyphs for mode/header/tab-line whose text needs to
 31645    be truncated.  This is used when the last visible character leaves
 31646    one or more columns till the window edge, but the next character is
 31647    wider than that number of columns, and therefore cannot fit on the
 31648    line.  We then replace these columns with the appropriate padding
 31649    character: '-' for the mode line and SPC for the other two.  That's
 31650    because these lines should not show the usual truncation glyphs
 31651    there.  This function is only used on TTY frames.  */
 31652 static void
 31653 pad_mode_line (struct it *it, bool mode_line_p)
 31654 {
 31655   struct it temp_it;
 31656   GLYPH glyph;
 31657 
 31658   eassert (!FRAME_WINDOW_P (it->f));
 31659   temp_it = *it;
 31660   temp_it.object = Qnil;
 31661   memset (&temp_it.current, 0, sizeof temp_it.current);
 31662 
 31663   SET_GLYPH (glyph, mode_line_p ? '-' : ' ', it->base_face_id);
 31664 
 31665   temp_it.dp = NULL;
 31666   temp_it.what = IT_CHARACTER;
 31667   temp_it.c = temp_it.char_to_display = GLYPH_CHAR (glyph);
 31668   temp_it.face_id = GLYPH_FACE (glyph);
 31669   temp_it.len = CHAR_BYTES (temp_it.c);
 31670 
 31671   PRODUCE_GLYPHS (&temp_it);
 31672   it->pixel_width = temp_it.pixel_width;
 31673   it->nglyphs = temp_it.nglyphs;
 31674 }
 31675 
 31676 #ifdef HAVE_WINDOW_SYSTEM
 31677 
 31678 /* Calculate line-height and line-spacing properties.
 31679    An integer value specifies explicit pixel value.
 31680    A float value specifies relative value to current face height.
 31681    A cons (float . face-name) specifies relative value to
 31682    height of specified face font.
 31683 
 31684    Returns height in pixels, or nil.  */
 31685 
 31686 static Lisp_Object
 31687 calc_line_height_property (struct it *it, Lisp_Object val, struct font *font,
 31688                            int boff, bool override)
 31689 {
 31690   Lisp_Object face_name = Qnil;
 31691   int ascent, descent, height;
 31692 
 31693   if (NILP (val) || INTEGERP (val) || (override && EQ (val, Qt)))
 31694     return val;
 31695 
 31696   if (CONSP (val))
 31697     {
 31698       face_name = XCAR (val);
 31699       val = XCDR (val);
 31700       if (!NUMBERP (val))
 31701         val = make_fixnum (1);
 31702       if (NILP (face_name))
 31703         {
 31704           height = it->ascent + it->descent;
 31705           goto scale;
 31706         }
 31707     }
 31708 
 31709   if (NILP (face_name))
 31710     {
 31711       font = FRAME_FONT (it->f);
 31712       boff = FRAME_BASELINE_OFFSET (it->f);
 31713     }
 31714   else if (EQ (face_name, Qt))
 31715     {
 31716       override = false;
 31717     }
 31718   else
 31719     {
 31720       int face_id;
 31721       struct face *face;
 31722 
 31723       face_id = lookup_named_face (it->w, it->f, face_name, false);
 31724       face = FACE_FROM_ID_OR_NULL (it->f, face_id);
 31725       if (face == NULL || ((font = face->font) == NULL))
 31726         return make_fixnum (-1);
 31727       boff = font->baseline_offset;
 31728       if (font->vertical_centering)
 31729         boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 31730     }
 31731 
 31732   normal_char_ascent_descent (font, -1, &ascent, &descent);
 31733 
 31734   if (override)
 31735     {
 31736       it->override_ascent = ascent;
 31737       it->override_descent = descent;
 31738       it->override_boff = boff;
 31739     }
 31740 
 31741   height = ascent + descent;
 31742 
 31743  scale:
 31744   /* FIXME: Check for overflow in multiplication or conversion.  */
 31745   if (FLOATP (val))
 31746     height = (int)(XFLOAT_DATA (val) * height);
 31747   else if (INTEGERP (val))
 31748     {
 31749       intmax_t v;
 31750       if (integer_to_intmax (val, &v))
 31751         height *= v;
 31752     }
 31753 
 31754   return make_fixnum (height);
 31755 }
 31756 
 31757 
 31758 /* Append a glyph for a glyphless character to IT->glyph_row.  FACE_ID
 31759    is a face ID to be used for the glyph.  FOR_NO_FONT is true if
 31760    and only if this is for a character for which no font was found.
 31761 
 31762    If the display method (it->glyphless_method) is
 31763    GLYPHLESS_DISPLAY_ACRONYM or GLYPHLESS_DISPLAY_HEX_CODE, LEN is a
 31764    length of the acronym or the hexadecimal string, UPPER_XOFF and
 31765    UPPER_YOFF are pixel offsets for the upper part of the string,
 31766    LOWER_XOFF and LOWER_YOFF are for the lower part.
 31767 
 31768    For the other display methods, LEN through LOWER_YOFF are zero.  */
 31769 
 31770 static void
 31771 append_glyphless_glyph (struct it *it, int face_id, bool for_no_font, int len,
 31772                         short upper_xoff, short upper_yoff,
 31773                         short lower_xoff, short lower_yoff)
 31774 {
 31775   struct glyph *glyph;
 31776   enum glyph_row_area area = it->area;
 31777 
 31778   glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
 31779   if (glyph < it->glyph_row->glyphs[area + 1])
 31780     {
 31781       /* If the glyph row is reversed, we need to prepend the glyph
 31782          rather than append it.  */
 31783       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31784         {
 31785           struct glyph *g;
 31786 
 31787           /* Make room for the additional glyph.  */
 31788           for (g = glyph - 1; g >= it->glyph_row->glyphs[area]; g--)
 31789             g[1] = *g;
 31790           glyph = it->glyph_row->glyphs[area];
 31791         }
 31792       glyph->charpos = CHARPOS (it->position);
 31793       glyph->object = it->object;
 31794       eassert (it->pixel_width <= SHRT_MAX);
 31795       glyph->pixel_width = it->pixel_width;
 31796       glyph->ascent = it->ascent;
 31797       glyph->descent = it->descent;
 31798       glyph->voffset = it->voffset;
 31799       glyph->type = GLYPHLESS_GLYPH;
 31800       glyph->u.glyphless.method = it->glyphless_method;
 31801       glyph->u.glyphless.for_no_font = for_no_font;
 31802       glyph->u.glyphless.len = len;
 31803       glyph->u.glyphless.ch = it->c;
 31804       glyph->slice.glyphless.upper_xoff = upper_xoff;
 31805       glyph->slice.glyphless.upper_yoff = upper_yoff;
 31806       glyph->slice.glyphless.lower_xoff = lower_xoff;
 31807       glyph->slice.glyphless.lower_yoff = lower_yoff;
 31808       glyph->avoid_cursor_p = it->avoid_cursor_p;
 31809       glyph->multibyte_p = it->multibyte_p;
 31810       if (it->glyph_row->reversed_p && area == TEXT_AREA)
 31811         {
 31812           /* In R2L rows, the left and the right box edges need to be
 31813              drawn in reverse direction.  */
 31814           glyph->right_box_line_p = it->start_of_box_run_p;
 31815           glyph->left_box_line_p = it->end_of_box_run_p;
 31816         }
 31817       else
 31818         {
 31819           glyph->left_box_line_p = it->start_of_box_run_p;
 31820           glyph->right_box_line_p = it->end_of_box_run_p;
 31821         }
 31822       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
 31823                                       || it->phys_descent > it->descent);
 31824       glyph->padding_p = false;
 31825       glyph->glyph_not_available_p = false;
 31826       glyph->face_id = face_id;
 31827       glyph->font_type = FONT_TYPE_UNKNOWN;
 31828       if (it->bidi_p)
 31829         {
 31830           glyph->resolved_level = it->bidi_it.resolved_level;
 31831           eassert ((it->bidi_it.type & 7) == it->bidi_it.type);
 31832           glyph->bidi_type = it->bidi_it.type;
 31833         }
 31834       ++it->glyph_row->used[area];
 31835     }
 31836   else
 31837     IT_EXPAND_MATRIX_WIDTH (it, area);
 31838 }
 31839 
 31840 
 31841 /* Produce a glyph for a glyphless character for iterator IT.
 31842    IT->glyphless_method specifies which method to use for displaying
 31843    the character.  See the description of enum
 31844    glyphless_display_method in dispextern.h for the detail.
 31845 
 31846    FOR_NO_FONT is true if and only if this is for a character for
 31847    which no font was found.  ACRONYM, if non-nil, is an acronym string
 31848    for the character.  */
 31849 
 31850 static void
 31851 produce_glyphless_glyph (struct it *it, bool for_no_font, Lisp_Object acronym)
 31852 {
 31853   int face_id;
 31854   struct face *face;
 31855   struct font *font;
 31856   int base_width, base_height, width, height;
 31857   short upper_xoff, upper_yoff, lower_xoff, lower_yoff;
 31858   int len;
 31859 
 31860   /* Get the metrics of the base font.  We always refer to the current
 31861      ASCII face.  */
 31862   face = FACE_FROM_ID (it->f, it->face_id)->ascii_face;
 31863   font = face->font ? face->font : FRAME_FONT (it->f);
 31864   normal_char_ascent_descent (font, -1, &it->ascent, &it->descent);
 31865   it->ascent += font->baseline_offset;
 31866   it->descent -= font->baseline_offset;
 31867   base_height = it->ascent + it->descent;
 31868   base_width = font->average_width;
 31869 
 31870   face_id = merge_glyphless_glyph_face (it);
 31871 
 31872   if (it->glyphless_method == GLYPHLESS_DISPLAY_THIN_SPACE)
 31873     {
 31874       it->pixel_width = THIN_SPACE_WIDTH;
 31875       len = 0;
 31876       upper_xoff = upper_yoff = lower_xoff = lower_yoff = 0;
 31877     }
 31878   else if (it->glyphless_method == GLYPHLESS_DISPLAY_EMPTY_BOX)
 31879     {
 31880       width = CHARACTER_WIDTH (it->c);
 31881       if (width == 0)
 31882         width = 1;
 31883       else if (width > 4)
 31884         width = 4;
 31885       it->pixel_width = base_width * width;
 31886       len = 0;
 31887       upper_xoff = upper_yoff = lower_xoff = lower_yoff = 0;
 31888     }
 31889   else
 31890     {
 31891       char buf[7];
 31892       const char *str;
 31893       unsigned int code[6];
 31894       int upper_len;
 31895       int ascent, descent;
 31896       struct font_metrics metrics_upper, metrics_lower;
 31897 
 31898       face = FACE_FROM_ID (it->f, face_id);
 31899       font = face->font ? face->font : FRAME_FONT (it->f);
 31900       prepare_face_for_display (it->f, face);
 31901 
 31902       if (it->glyphless_method == GLYPHLESS_DISPLAY_ACRONYM)
 31903         {
 31904           if (! STRINGP (acronym) && CHAR_TABLE_P (Vglyphless_char_display))
 31905             acronym = CHAR_TABLE_REF (Vglyphless_char_display, it->c);
 31906           if (CONSP (acronym))
 31907             acronym = XCAR (acronym);
 31908           str = STRINGP (acronym) ? SSDATA (acronym) : "";
 31909         }
 31910       else
 31911         {
 31912           eassert (it->glyphless_method == GLYPHLESS_DISPLAY_HEX_CODE);
 31913           sprintf (buf, "%0*X", it->c < 0x10000 ? 4 : 6, it->c + 0u);
 31914           str = buf;
 31915         }
 31916       for (len = 0; str[len] && ASCII_CHAR_P (str[len]) && len < 6; len++)
 31917         code[len] = font->driver->encode_char (font, str[len]);
 31918       upper_len = (len + 1) / 2;
 31919       font->driver->text_extents (font, code, upper_len,
 31920                                   &metrics_upper);
 31921       font->driver->text_extents (font, code + upper_len, len - upper_len,
 31922                                   &metrics_lower);
 31923 
 31924 
 31925 
 31926       /* +4 is for vertical bars of a box plus 1-pixel spaces at both side.  */
 31927       width = max (metrics_upper.width, metrics_lower.width) + 4;
 31928       upper_xoff = lower_xoff = 2; /* the typical case */
 31929       if (base_width >= width)
 31930         {
 31931           /* Align the upper to the left, the lower to the right.  */
 31932           it->pixel_width = base_width;
 31933           lower_xoff = base_width - 2 - metrics_lower.width;
 31934         }
 31935       else
 31936         {
 31937           /* Center the shorter one.  */
 31938           it->pixel_width = width;
 31939           if (metrics_upper.width >= metrics_lower.width)
 31940             lower_xoff = (width - metrics_lower.width) / 2;
 31941           else
 31942             upper_xoff = (width - metrics_upper.width) / 2;
 31943         }
 31944 
 31945       /* +5 is for horizontal bars of a box plus 1-pixel spaces at
 31946          top, bottom, and between upper and lower strings.  */
 31947       height = (metrics_upper.ascent + metrics_upper.descent
 31948                 + metrics_lower.ascent + metrics_lower.descent) + 5;
 31949       /* Center vertically.
 31950          H:base_height, D:base_descent
 31951          h:height, ld:lower_descent, la:lower_ascent, ud:upper_descent
 31952 
 31953          ascent = - (D - H/2 - h/2 + 1); "+ 1" for rounding up
 31954          descent = D - H/2 + h/2;
 31955          lower_yoff = descent - 2 - ld;
 31956          upper_yoff = lower_yoff - la - 1 - ud;  */
 31957       ascent = - (it->descent - (base_height + height + 1) / 2);
 31958       descent = it->descent - (base_height - height) / 2;
 31959       lower_yoff = descent - 2 - metrics_lower.descent;
 31960       upper_yoff = (lower_yoff - metrics_lower.ascent - 1
 31961                     - metrics_upper.descent);
 31962       /* Don't make the height shorter than the base height.  */
 31963       if (height > base_height)
 31964         {
 31965           it->ascent = ascent;
 31966           it->descent = descent;
 31967         }
 31968     }
 31969 
 31970   it->phys_ascent = it->ascent;
 31971   it->phys_descent = it->descent;
 31972   if (it->glyph_row)
 31973     append_glyphless_glyph (it, face_id, for_no_font, len,
 31974                             upper_xoff, upper_yoff,
 31975                             lower_xoff, lower_yoff);
 31976   it->nglyphs = 1;
 31977   take_vertical_position_into_account (it);
 31978 }
 31979 
 31980 
 31981 /* If face has a box, add the box thickness to the character
 31982    height.  If character has a box line to the left and/or
 31983    right, add the box line width to the character's width.  */
 31984 #define IT_APPLY_FACE_BOX(it, face)                             \
 31985   do {                                                          \
 31986     if (face->box != FACE_NO_BOX)                               \
 31987       {                                                         \
 31988         int thick = face->box_horizontal_line_width;            \
 31989         if (thick > 0)                                          \
 31990           {                                                     \
 31991             it->ascent += thick;                                \
 31992             it->descent += thick;                               \
 31993           }                                                     \
 31994                                                                 \
 31995         thick = face->box_vertical_line_width;                  \
 31996         if (thick > 0)                                          \
 31997           {                                                     \
 31998             if (it->start_of_box_run_p)                         \
 31999               it->pixel_width += thick;                         \
 32000             if (it->end_of_box_run_p)                           \
 32001               it->pixel_width += thick;                         \
 32002           }                                                     \
 32003       }                                                         \
 32004     } while (false)
 32005 
 32006 /* RIF:
 32007    Produce glyphs/get display metrics for the display element IT is
 32008    loaded with.  See the description of struct it in dispextern.h
 32009    for an overview of struct it.  */
 32010 
 32011 void
 32012 gui_produce_glyphs (struct it *it)
 32013 {
 32014   int extra_line_spacing = it->extra_line_spacing;
 32015 
 32016   it->glyph_not_available_p = false;
 32017 
 32018   if (it->what == IT_CHARACTER)
 32019     {
 32020       unsigned char2b;
 32021       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 32022       struct font *font = face->font;
 32023       struct font_metrics *pcm = NULL;
 32024       int boff;                 /* Baseline offset.  */
 32025 
 32026       if (font == NULL)
 32027         {
 32028           /* When no suitable font is found, display this character by
 32029              the method specified in the first extra slot of
 32030              Vglyphless_char_display.  */
 32031           Lisp_Object acronym = lookup_glyphless_char_display (-1, it);
 32032 
 32033           eassert (it->what == IT_GLYPHLESS);
 32034           produce_glyphless_glyph (it, true,
 32035                                    STRINGP (acronym) ? acronym : Qnil);
 32036           goto done;
 32037         }
 32038 
 32039       boff = font->baseline_offset;
 32040       if (font->vertical_centering)
 32041         boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 32042 
 32043       if (it->char_to_display != '\n' && it->char_to_display != '\t')
 32044         {
 32045           it->nglyphs = 1;
 32046 
 32047           if (it->override_ascent >= 0)
 32048             {
 32049               it->ascent = it->override_ascent;
 32050               it->descent = it->override_descent;
 32051               boff = it->override_boff;
 32052             }
 32053           else
 32054             {
 32055               it->ascent = FONT_BASE (font) + boff;
 32056               it->descent = FONT_DESCENT (font) - boff;
 32057             }
 32058 
 32059           if (get_char_glyph_code (it->char_to_display, font, &char2b))
 32060             {
 32061               pcm = get_per_char_metric (font, &char2b);
 32062               if (pcm->width == 0
 32063                   && pcm->rbearing == 0 && pcm->lbearing == 0)
 32064                 pcm = NULL;
 32065             }
 32066 
 32067           if (pcm)
 32068             {
 32069               it->phys_ascent = pcm->ascent + boff;
 32070               it->phys_descent = pcm->descent - boff;
 32071               it->pixel_width = pcm->width;
 32072               /* Don't use font-global values for ascent and descent
 32073                  if they result in an exceedingly large line height.  */
 32074               if (it->override_ascent < 0)
 32075                 {
 32076                   if (FONT_TOO_HIGH (font))
 32077                     {
 32078                       it->ascent = it->phys_ascent;
 32079                       it->descent = it->phys_descent;
 32080                       /* These limitations are enforced by an
 32081                          assertion near the end of this function.  */
 32082                       if (it->ascent < 0)
 32083                         it->ascent = 0;
 32084                       if (it->descent < 0)
 32085                         it->descent = 0;
 32086                     }
 32087                 }
 32088             }
 32089           else
 32090             {
 32091               it->glyph_not_available_p = true;
 32092               it->phys_ascent = it->ascent;
 32093               it->phys_descent = it->descent;
 32094               it->pixel_width = font->space_width;
 32095             }
 32096 
 32097           if (it->constrain_row_ascent_descent_p)
 32098             {
 32099               if (it->descent > it->max_descent)
 32100                 {
 32101                   it->ascent += it->descent - it->max_descent;
 32102                   it->descent = it->max_descent;
 32103                 }
 32104               if (it->ascent > it->max_ascent)
 32105                 {
 32106                   it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
 32107                   it->ascent = it->max_ascent;
 32108                 }
 32109               it->phys_ascent = min (it->phys_ascent, it->ascent);
 32110               it->phys_descent = min (it->phys_descent, it->descent);
 32111               extra_line_spacing = 0;
 32112             }
 32113 
 32114           /* If this is a space inside a region of text with
 32115              `space-width' property, change its width.  */
 32116           bool stretched_p
 32117             = it->char_to_display == ' ' && !NILP (it->space_width);
 32118           if (stretched_p)
 32119             it->pixel_width *= XFLOATINT (it->space_width);
 32120 
 32121           IT_APPLY_FACE_BOX(it, face);
 32122 
 32123           /* If face has an overline, add the height of the overline
 32124              (1 pixel) and a 1 pixel margin to the character height.  */
 32125           if (face->overline_p)
 32126             it->ascent += clip_to_bounds (0, overline_margin, 1000000);
 32127 
 32128           if (it->constrain_row_ascent_descent_p)
 32129             {
 32130               if (it->ascent > it->max_ascent)
 32131                 it->ascent = it->max_ascent;
 32132               if (it->descent > it->max_descent)
 32133                 it->descent = it->max_descent;
 32134             }
 32135 
 32136           take_vertical_position_into_account (it);
 32137 
 32138           /* If we have to actually produce glyphs, do it.  */
 32139           if (it->glyph_row)
 32140             {
 32141               if (stretched_p)
 32142                 {
 32143                   /* Translate a space with a `space-width' property
 32144                      into a stretch glyph.  */
 32145                   int ascent = (((it->ascent + it->descent) * FONT_BASE (font))
 32146                                 / FONT_HEIGHT (font));
 32147                   append_stretch_glyph (it, it->object, it->pixel_width,
 32148                                         it->ascent + it->descent, ascent);
 32149                 }
 32150               else
 32151                 append_glyph (it);
 32152 
 32153               /* If characters with lbearing or rbearing are displayed
 32154                  in this line, record that fact in a flag of the
 32155                  glyph row.  This is used to optimize X output code.  */
 32156               if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
 32157                 it->glyph_row->contains_overlapping_glyphs_p = true;
 32158             }
 32159           if (! stretched_p && it->pixel_width == 0)
 32160             /* We assure that all visible glyphs have at least 1-pixel
 32161                width.  */
 32162             it->pixel_width = 1;
 32163         }
 32164       else if (it->char_to_display == '\n')
 32165         {
 32166           /* A newline has no width, but we need the height of the
 32167              line.  But if previous part of the line sets a height,
 32168              don't increase that height.  */
 32169 
 32170           Lisp_Object height;
 32171           Lisp_Object total_height = Qnil;
 32172 
 32173           it->override_ascent = -1;
 32174           it->pixel_width = 0;
 32175           it->nglyphs = 0;
 32176 
 32177           height = get_it_property (it, Qline_height);
 32178           /* Split (line-height total-height) list.  */
 32179           if (CONSP (height)
 32180               && CONSP (XCDR (height))
 32181               && NILP (XCDR (XCDR (height))))
 32182             {
 32183               total_height = XCAR (XCDR (height));
 32184               height = XCAR (height);
 32185             }
 32186           height = calc_line_height_property (it, height, font, boff, true);
 32187 
 32188           if (it->override_ascent >= 0)
 32189             {
 32190               it->ascent = it->override_ascent;
 32191               it->descent = it->override_descent;
 32192               boff = it->override_boff;
 32193             }
 32194           else
 32195             {
 32196               if (FONT_TOO_HIGH (font))
 32197                 {
 32198                   it->ascent = font->pixel_size + boff - 1;
 32199                   it->descent = -boff + 1;
 32200                   if (it->descent < 0)
 32201                     it->descent = 0;
 32202                 }
 32203               else
 32204                 {
 32205                   it->ascent = FONT_BASE (font) + boff;
 32206                   it->descent = FONT_DESCENT (font) - boff;
 32207                 }
 32208             }
 32209 
 32210           if (EQ (height, Qt))
 32211             {
 32212               if (it->descent > it->max_descent)
 32213                 {
 32214                   it->ascent += it->descent - it->max_descent;
 32215                   it->descent = it->max_descent;
 32216                 }
 32217               if (it->ascent > it->max_ascent)
 32218                 {
 32219                   it->descent = min (it->max_descent, it->descent + it->ascent - it->max_ascent);
 32220                   it->ascent = it->max_ascent;
 32221                 }
 32222               it->phys_ascent = min (it->phys_ascent, it->ascent);
 32223               it->phys_descent = min (it->phys_descent, it->descent);
 32224               it->constrain_row_ascent_descent_p = true;
 32225               extra_line_spacing = 0;
 32226             }
 32227           else
 32228             {
 32229               Lisp_Object spacing;
 32230 
 32231               it->phys_ascent = it->ascent;
 32232               it->phys_descent = it->descent;
 32233 
 32234               if ((it->max_ascent > 0 || it->max_descent > 0)
 32235                   && face->box != FACE_NO_BOX
 32236                   && face->box_horizontal_line_width > 0)
 32237                 {
 32238                   it->ascent += face->box_horizontal_line_width;
 32239                   it->descent += face->box_horizontal_line_width;
 32240                 }
 32241               if (!NILP (height)
 32242                   && XFIXNUM (height) > it->ascent + it->descent)
 32243                 it->ascent = XFIXNUM (height) - it->descent;
 32244 
 32245               if (!NILP (total_height))
 32246                 spacing = calc_line_height_property (it, total_height, font,
 32247                                                      boff, false);
 32248               else
 32249                 {
 32250                   spacing = get_it_property (it, Qline_spacing);
 32251                   spacing = calc_line_height_property (it, spacing, font,
 32252                                                        boff, false);
 32253                 }
 32254               if (FIXNUMP (spacing))
 32255                 {
 32256                   extra_line_spacing = XFIXNUM (spacing);
 32257                   if (!NILP (total_height))
 32258                     extra_line_spacing -= (it->phys_ascent + it->phys_descent);
 32259                 }
 32260             }
 32261         }
 32262       else                    /* i.e. (it->char_to_display == '\t') */
 32263         {
 32264           if (font->space_width > 0)
 32265             {
 32266               int tab_width = it->tab_width * font->space_width;
 32267               int x = it->current_x + it->continuation_lines_width;
 32268               int x0 = x;
 32269               /* Adjust for line numbers, if needed.   */
 32270               if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 32271                 {
 32272                   x -= it->lnum_pixel_width;
 32273                   /* Restore the original TAB width, if required.  */
 32274                   if (x + it->stretch_adjust >= it->first_visible_x)
 32275                     x += it->stretch_adjust;
 32276                 }
 32277 
 32278               int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
 32279 
 32280               /* If the distance from the current position to the next tab
 32281                  stop is less than a space character width, use the
 32282                  tab stop after that.  */
 32283               if (next_tab_x - x < font->space_width)
 32284                 next_tab_x += tab_width;
 32285               if (!NILP (Vdisplay_line_numbers) && it->line_number_produced_p)
 32286                 {
 32287                   next_tab_x += it->lnum_pixel_width;
 32288                   /* If the line is hscrolled, and the TAB starts before
 32289                      the first visible pixel, simulate negative row->x.  */
 32290                   if (x < it->first_visible_x)
 32291                     {
 32292                       next_tab_x -= it->first_visible_x - x;
 32293                       it->stretch_adjust = it->first_visible_x - x;
 32294                     }
 32295                   else
 32296                     next_tab_x -= it->stretch_adjust;
 32297                 }
 32298 
 32299               it->pixel_width = next_tab_x - x0;
 32300               it->nglyphs = 1;
 32301               if (FONT_TOO_HIGH (font))
 32302                 {
 32303                   if (get_char_glyph_code (' ', font, &char2b))
 32304                     {
 32305                       pcm = get_per_char_metric (font, &char2b);
 32306                       if (pcm->width == 0
 32307                           && pcm->rbearing == 0 && pcm->lbearing == 0)
 32308                         pcm = NULL;
 32309                     }
 32310 
 32311                   if (pcm)
 32312                     {
 32313                       it->ascent = pcm->ascent + boff;
 32314                       it->descent = pcm->descent - boff;
 32315                     }
 32316                   else
 32317                     {
 32318                       it->ascent = font->pixel_size + boff - 1;
 32319                       it->descent = -boff + 1;
 32320                     }
 32321                   if (it->ascent < 0)
 32322                     it->ascent = 0;
 32323                   if (it->descent < 0)
 32324                     it->descent = 0;
 32325                 }
 32326               else
 32327                 {
 32328                   it->ascent = FONT_BASE (font) + boff;
 32329                   it->descent = FONT_DESCENT (font) - boff;
 32330                 }
 32331               it->phys_ascent = it->ascent;
 32332               it->phys_descent = it->descent;
 32333 
 32334               if (it->glyph_row)
 32335                 {
 32336                   append_stretch_glyph (it, it->object, it->pixel_width,
 32337                                         it->ascent + it->descent, it->ascent);
 32338                 }
 32339             }
 32340           else
 32341             {
 32342               it->pixel_width = 0;
 32343               it->nglyphs = 1;
 32344             }
 32345         }
 32346 
 32347       if (FONT_TOO_HIGH (font))
 32348         {
 32349           int font_ascent, font_descent;
 32350 
 32351           /* For very large fonts, where we ignore the declared font
 32352              dimensions, and go by per-character metrics instead,
 32353              don't let the row ascent and descent values (and the row
 32354              height computed from them) be smaller than the "normal"
 32355              character metrics.  This avoids unpleasant effects
 32356              whereby lines on display would change their height
 32357              depending on which characters are shown.  */
 32358           normal_char_ascent_descent (font, -1, &font_ascent, &font_descent);
 32359           it->max_ascent = max (it->max_ascent, font_ascent);
 32360           it->max_descent = max (it->max_descent, font_descent);
 32361         }
 32362 
 32363       if (it->ascent < 0)
 32364         it->ascent = 0;
 32365       if (it->descent < 0)
 32366         it->descent = 0;
 32367     }
 32368   else if (it->what == IT_COMPOSITION && it->cmp_it.ch < 0)
 32369     {
 32370       /* A static composition.
 32371 
 32372          Note: A composition is represented as one glyph in the
 32373          glyph matrix.  There are no padding glyphs.
 32374 
 32375          Important note: pixel_width, ascent, and descent are the
 32376          values of what is drawn by draw_glyphs (i.e. the values of
 32377          the overall glyphs composed).  */
 32378       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 32379       int boff;                 /* baseline offset */
 32380       struct composition *cmp = composition_table[it->cmp_it.id];
 32381       int glyph_len = cmp->glyph_len;
 32382       struct font *font = face->font;
 32383 
 32384       it->nglyphs = 1;
 32385 
 32386       /* If we have not yet calculated pixel size data of glyphs of
 32387          the composition for the current face font, calculate them
 32388          now.  Theoretically, we have to check all fonts for the
 32389          glyphs, but that requires much time and memory space.  So,
 32390          here we check only the font of the first glyph.  This may
 32391          lead to incorrect display, but it's very rare, and C-l
 32392          (recenter-top-bottom) can correct the display anyway.  */
 32393       if (! cmp->font || cmp->font != font)
 32394         {
 32395           /* Ascent and descent of the font of the first character
 32396              of this composition (adjusted by baseline offset).
 32397              Ascent and descent of overall glyphs should not be less
 32398              than these, respectively.  */
 32399           int font_ascent, font_descent, font_height;
 32400           /* Bounding box of the overall glyphs.  */
 32401           int leftmost, rightmost, lowest, highest;
 32402           int lbearing, rbearing;
 32403           int i, width, ascent, descent;
 32404           int c;
 32405           unsigned char2b;
 32406           struct font_metrics *pcm;
 32407           ptrdiff_t pos;
 32408 
 32409           eassume (0 < glyph_len); /* See Bug#8512.  */
 32410           do
 32411             c = COMPOSITION_GLYPH (cmp, glyph_len - 1);
 32412           while (c == '\t' && 0 < --glyph_len);
 32413 
 32414           bool right_padded = glyph_len < cmp->glyph_len;
 32415           for (i = 0; i < glyph_len; i++)
 32416             {
 32417               c = COMPOSITION_GLYPH (cmp, i);
 32418               if (c != '\t')
 32419                 break;
 32420               cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
 32421             }
 32422           bool left_padded = i > 0;
 32423 
 32424           pos = (STRINGP (it->string) ? IT_STRING_CHARPOS (*it)
 32425                  : IT_CHARPOS (*it));
 32426           /* If no suitable font is found, use the default font.  */
 32427           bool font_not_found_p = font == NULL;
 32428           if (font_not_found_p)
 32429             {
 32430               face = face->ascii_face;
 32431               font = face->font;
 32432             }
 32433           boff = font->baseline_offset;
 32434           if (font->vertical_centering)
 32435             boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
 32436           normal_char_ascent_descent (font, -1, &font_ascent, &font_descent);
 32437           font_ascent +=  boff;
 32438           font_descent -= boff;
 32439           font_height = font_ascent + font_descent;
 32440 
 32441           cmp->font = font;
 32442 
 32443           pcm = NULL;
 32444           if (! font_not_found_p)
 32445             {
 32446               get_char_face_and_encoding (it->f, c, it->face_id,
 32447                                           &char2b, false);
 32448               pcm = get_per_char_metric (font, &char2b);
 32449             }
 32450 
 32451           /* Initialize the bounding box.  */
 32452           if (pcm)
 32453             {
 32454               width = cmp->glyph_len > 0 ? pcm->width : 0;
 32455               ascent = pcm->ascent;
 32456               descent = pcm->descent;
 32457               lbearing = pcm->lbearing;
 32458               rbearing = pcm->rbearing;
 32459             }
 32460           else
 32461             {
 32462               width = cmp->glyph_len > 0 ? font->space_width : 0;
 32463               ascent = FONT_BASE (font);
 32464               descent = FONT_DESCENT (font);
 32465               lbearing = 0;
 32466               rbearing = width;
 32467             }
 32468 
 32469           rightmost = width;
 32470           leftmost = 0;
 32471           lowest = - descent + boff;
 32472           highest = ascent + boff;
 32473 
 32474           if (! font_not_found_p
 32475               && font->default_ascent
 32476               && CHAR_TABLE_P (Vuse_default_ascent)
 32477               && !NILP (Faref (Vuse_default_ascent,
 32478                                make_fixnum (it->char_to_display))))
 32479             highest = font->default_ascent + boff;
 32480 
 32481           /* Draw the first glyph at the normal position.  It may be
 32482              shifted to right later if some other glyphs are drawn
 32483              at the left.  */
 32484           cmp->offsets[i * 2] = 0;
 32485           cmp->offsets[i * 2 + 1] = boff;
 32486           cmp->lbearing = lbearing;
 32487           cmp->rbearing = rbearing;
 32488 
 32489           /* Set cmp->offsets for the remaining glyphs.  */
 32490           for (i++; i < glyph_len; i++)
 32491             {
 32492               int left, right, btm, top;
 32493               int ch = COMPOSITION_GLYPH (cmp, i);
 32494               int face_id;
 32495               struct face *this_face;
 32496 
 32497               if (ch == '\t')
 32498                 ch = ' ';
 32499               face_id = FACE_FOR_CHAR (it->f, face, ch, pos, it->string);
 32500               this_face = FACE_FROM_ID (it->f, face_id);
 32501               font = this_face->font;
 32502 
 32503               if (font == NULL)
 32504                 pcm = NULL;
 32505               else
 32506                 {
 32507                   get_char_face_and_encoding (it->f, ch, face_id,
 32508                                               &char2b, false);
 32509                   pcm = get_per_char_metric (font, &char2b);
 32510                 }
 32511               if (! pcm)
 32512                 cmp->offsets[i * 2] = cmp->offsets[i * 2 + 1] = 0;
 32513               else
 32514                 {
 32515                   width = pcm->width;
 32516                   ascent = pcm->ascent;
 32517                   descent = pcm->descent;
 32518                   lbearing = pcm->lbearing;
 32519                   rbearing = pcm->rbearing;
 32520                   if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
 32521                     {
 32522                       /* Relative composition with or without
 32523                          alternate chars.  */
 32524                       left = (leftmost + rightmost - width) / 2;
 32525                       btm = - descent + boff;
 32526                       if (font->relative_compose
 32527                           && (! CHAR_TABLE_P (Vignore_relative_composition)
 32528                               || NILP (Faref (Vignore_relative_composition,
 32529                                               make_fixnum (ch)))))
 32530                         {
 32531 
 32532                           if (- descent >= font->relative_compose)
 32533                             /* One extra pixel between two glyphs.  */
 32534                             btm = highest + 1;
 32535                           else if (ascent <= 0)
 32536                             /* One extra pixel between two glyphs.  */
 32537                             btm = lowest - 1 - ascent - descent;
 32538                         }
 32539                     }
 32540                   else
 32541                     {
 32542                       /* A composition rule is specified by an integer
 32543                          value that encodes global and new reference
 32544                          points (GREF and NREF).  GREF and NREF are
 32545                          specified by numbers as below:
 32546 
 32547                          0---1---2 -- ascent
 32548                          |       |
 32549                          |       |
 32550                          |       |
 32551                          9--10--11 -- center
 32552                          |       |
 32553                          ---3---4---5--- baseline
 32554                          |       |
 32555                          6---7---8 -- descent
 32556                       */
 32557                       int rule = COMPOSITION_RULE (cmp, i);
 32558                       int gref, nref, grefx, grefy, nrefx, nrefy, xoff, yoff;
 32559 
 32560                       COMPOSITION_DECODE_RULE (rule, gref, nref, xoff, yoff);
 32561                       grefx = gref % 3, nrefx = nref % 3;
 32562                       grefy = gref / 3, nrefy = nref / 3;
 32563                       if (xoff)
 32564                         xoff = font_height * (xoff - 128) / 256;
 32565                       if (yoff)
 32566                         yoff = font_height * (yoff - 128) / 256;
 32567 
 32568                       left = (leftmost
 32569                               + grefx * (rightmost - leftmost) / 2
 32570                               - nrefx * width / 2
 32571                               + xoff);
 32572 
 32573                       btm = ((grefy == 0 ? highest
 32574                               : grefy == 1 ? 0
 32575                               : grefy == 2 ? lowest
 32576                               : (highest + lowest) / 2)
 32577                              - (nrefy == 0 ? ascent + descent
 32578                                 : nrefy == 1 ? descent - boff
 32579                                 : nrefy == 2 ? 0
 32580                                 : (ascent + descent) / 2)
 32581                              + yoff);
 32582                     }
 32583 
 32584                   cmp->offsets[i * 2] = left;
 32585                   cmp->offsets[i * 2 + 1] = btm + descent;
 32586 
 32587                   /* Update the bounding box of the overall glyphs. */
 32588                   if (width > 0)
 32589                     {
 32590                       right = left + width;
 32591                       if (left < leftmost)
 32592                         leftmost = left;
 32593                       if (right > rightmost)
 32594                         rightmost = right;
 32595                     }
 32596                   top = btm + descent + ascent;
 32597                   if (top > highest)
 32598                     highest = top;
 32599                   if (btm < lowest)
 32600                     lowest = btm;
 32601 
 32602                   if (cmp->lbearing > left + lbearing)
 32603                     cmp->lbearing = left + lbearing;
 32604                   if (cmp->rbearing < left + rbearing)
 32605                     cmp->rbearing = left + rbearing;
 32606                 }
 32607             }
 32608 
 32609           /* If there are glyphs whose x-offsets are negative,
 32610              shift all glyphs to the right and make all x-offsets
 32611              non-negative.  */
 32612           if (leftmost < 0)
 32613             {
 32614               for (i = 0; i < cmp->glyph_len; i++)
 32615                 cmp->offsets[i * 2] -= leftmost;
 32616               rightmost -= leftmost;
 32617               cmp->lbearing -= leftmost;
 32618               cmp->rbearing -= leftmost;
 32619             }
 32620 
 32621           if (left_padded && cmp->lbearing < 0)
 32622             {
 32623               for (i = 0; i < cmp->glyph_len; i++)
 32624                 cmp->offsets[i * 2] -= cmp->lbearing;
 32625               rightmost -= cmp->lbearing;
 32626               cmp->rbearing -= cmp->lbearing;
 32627               cmp->lbearing = 0;
 32628             }
 32629           if (right_padded && rightmost < cmp->rbearing)
 32630             {
 32631               rightmost = cmp->rbearing;
 32632             }
 32633 
 32634           cmp->pixel_width = rightmost;
 32635           cmp->ascent = highest;
 32636           cmp->descent = - lowest;
 32637           if (cmp->ascent < font_ascent)
 32638             cmp->ascent = font_ascent;
 32639           if (cmp->descent < font_descent)
 32640             cmp->descent = font_descent;
 32641         }
 32642 
 32643       if (it->glyph_row
 32644           && (cmp->lbearing < 0
 32645               || cmp->rbearing > cmp->pixel_width))
 32646         it->glyph_row->contains_overlapping_glyphs_p = true;
 32647 
 32648       it->pixel_width = cmp->pixel_width;
 32649       it->ascent = it->phys_ascent = cmp->ascent;
 32650       it->descent = it->phys_descent = cmp->descent;
 32651       IT_APPLY_FACE_BOX(it, face);
 32652 
 32653       /* If face has an overline, add the height of the overline
 32654          (1 pixel) and a 1 pixel margin to the character height.  */
 32655       if (face->overline_p)
 32656         it->ascent += clip_to_bounds (0, overline_margin, 1000000);
 32657 
 32658       take_vertical_position_into_account (it);
 32659       if (it->ascent < 0)
 32660         it->ascent = 0;
 32661       if (it->descent < 0)
 32662         it->descent = 0;
 32663 
 32664       if (it->glyph_row && cmp->glyph_len > 0)
 32665         append_composite_glyph (it);
 32666     }
 32667   else if (it->what == IT_COMPOSITION)
 32668     {
 32669       /* A dynamic (automatic) composition.  */
 32670       struct face *face = FACE_FROM_ID (it->f, it->face_id);
 32671       Lisp_Object gstring;
 32672       struct font_metrics metrics;
 32673 
 32674       it->nglyphs = 1;
 32675 
 32676       gstring = composition_gstring_from_id (it->cmp_it.id);
 32677       it->pixel_width
 32678         = composition_gstring_width (gstring, it->cmp_it.from, it->cmp_it.to,
 32679                                      &metrics);
 32680       if (it->pixel_width == 0)
 32681         {
 32682           it->glyph_not_available_p = true;
 32683           it->phys_ascent = it->ascent;
 32684           it->phys_descent = it->descent;
 32685           it->pixel_width = face->font->space_width;
 32686         }
 32687       else
 32688         {
 32689           if (it->glyph_row
 32690               && (metrics.lbearing < 0 || metrics.rbearing > metrics.width))
 32691             it->glyph_row->contains_overlapping_glyphs_p = true;
 32692           it->ascent = it->phys_ascent = metrics.ascent;
 32693           it->descent = it->phys_descent = metrics.descent;
 32694         }
 32695       IT_APPLY_FACE_BOX(it, face);
 32696 
 32697       /* If face has an overline, add the height of the overline
 32698          (1 pixel) and a 1 pixel margin to the character height.  */
 32699       if (face->overline_p)
 32700         it->ascent += clip_to_bounds (0, overline_margin, 1000000);
 32701       take_vertical_position_into_account (it);
 32702       if (it->ascent < 0)
 32703         it->ascent = 0;
 32704       if (it->descent < 0)
 32705         it->descent = 0;
 32706 
 32707       if (it->glyph_row)
 32708         append_composite_glyph (it);
 32709     }
 32710   else if (it->what == IT_GLYPHLESS)
 32711     produce_glyphless_glyph (it, false, Qnil);
 32712   else if (it->what == IT_IMAGE)
 32713     produce_image_glyph (it);
 32714   else if (it->what == IT_STRETCH)
 32715     produce_stretch_glyph (it);
 32716   else if (it->what == IT_XWIDGET)
 32717     produce_xwidget_glyph (it);
 32718 
 32719  done:
 32720   /* Accumulate dimensions.  Note: can't assume that it->descent > 0
 32721      because this isn't true for images with `:ascent 100'.  */
 32722   eassert (it->ascent >= 0 && it->descent >= 0);
 32723   if (it->area == TEXT_AREA)
 32724     it->current_x += it->pixel_width;
 32725 
 32726   if (extra_line_spacing > 0)
 32727     {
 32728       it->descent += extra_line_spacing;
 32729       if (extra_line_spacing > it->max_extra_line_spacing)
 32730         it->max_extra_line_spacing = extra_line_spacing;
 32731     }
 32732 
 32733   it->max_ascent = max (it->max_ascent, it->ascent);
 32734   it->max_descent = max (it->max_descent, it->descent);
 32735   it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
 32736   it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
 32737 }
 32738 
 32739 /* EXPORT for RIF:
 32740    Output LEN glyphs starting at START at the nominal cursor position.
 32741    Advance the nominal cursor over the text.  UPDATED_ROW is the glyph row
 32742    being updated, and UPDATED_AREA is the area of that row being updated.  */
 32743 
 32744 void
 32745 gui_write_glyphs (struct window *w, struct glyph_row *updated_row,
 32746                 struct glyph *start, enum glyph_row_area updated_area, int len)
 32747 {
 32748   int x, hpos, chpos = w->phys_cursor.hpos;
 32749 
 32750   eassert (updated_row);
 32751   /* When the window is hscrolled, cursor hpos can legitimately be out
 32752      of bounds, but we draw the cursor at the corresponding window
 32753      margin in that case.  */
 32754   if (!updated_row->reversed_p && chpos < 0)
 32755     chpos = 0;
 32756   if (updated_row->reversed_p && chpos >= updated_row->used[TEXT_AREA])
 32757     chpos = updated_row->used[TEXT_AREA] - 1;
 32758 
 32759   block_input ();
 32760 
 32761   /* Write glyphs.  */
 32762 
 32763   hpos = start - updated_row->glyphs[updated_area];
 32764   x = draw_glyphs (w, w->output_cursor.x,
 32765                    updated_row, updated_area,
 32766                    hpos, hpos + len,
 32767                    DRAW_NORMAL_TEXT, 0);
 32768 
 32769   /* Invalidate old phys cursor if the glyph at its hpos is redrawn.  */
 32770   if (updated_area == TEXT_AREA
 32771       && w->phys_cursor_on_p
 32772       && w->phys_cursor.vpos == w->output_cursor.vpos
 32773       && chpos >= hpos
 32774       && chpos < hpos + len)
 32775     w->phys_cursor_on_p = false;
 32776 
 32777   unblock_input ();
 32778 
 32779   /* Advance the output cursor.  */
 32780   w->output_cursor.hpos += len;
 32781   w->output_cursor.x = x;
 32782 }
 32783 
 32784 
 32785 /* EXPORT for RIF:
 32786    Insert LEN glyphs from START at the nominal cursor position.  */
 32787 
 32788 void
 32789 gui_insert_glyphs (struct window *w, struct glyph_row *updated_row,
 32790                  struct glyph *start, enum glyph_row_area updated_area, int len)
 32791 {
 32792   struct frame *f;
 32793   int line_height, shift_by_width, shifted_region_width;
 32794   struct glyph_row *row;
 32795   struct glyph *glyph;
 32796   int frame_x, frame_y;
 32797   ptrdiff_t hpos;
 32798 
 32799   eassert (updated_row);
 32800   block_input ();
 32801   f = XFRAME (WINDOW_FRAME (w));
 32802 
 32803   /* Get the height of the line we are in.  */
 32804   row = updated_row;
 32805   line_height = row->height;
 32806 
 32807   /* Get the width of the glyphs to insert.  */
 32808   shift_by_width = 0;
 32809   for (glyph = start; glyph < start + len; ++glyph)
 32810     shift_by_width += glyph->pixel_width;
 32811 
 32812   /* Get the width of the region to shift right.  */
 32813   shifted_region_width = (window_box_width (w, updated_area)
 32814                           - w->output_cursor.x
 32815                           - shift_by_width);
 32816 
 32817   /* Shift right.  */
 32818   frame_x = window_box_left (w, updated_area) + w->output_cursor.x;
 32819   frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, w->output_cursor.y);
 32820 
 32821   FRAME_RIF (f)->shift_glyphs_for_insert (f, frame_x, frame_y, shifted_region_width,
 32822                                           line_height, shift_by_width);
 32823 
 32824   /* Write the glyphs.  */
 32825   hpos = start - row->glyphs[updated_area];
 32826   draw_glyphs (w, w->output_cursor.x, row, updated_area,
 32827                hpos, hpos + len,
 32828                DRAW_NORMAL_TEXT, 0);
 32829 
 32830   /* Advance the output cursor.  */
 32831   w->output_cursor.hpos += len;
 32832   w->output_cursor.x += shift_by_width;
 32833   unblock_input ();
 32834 }
 32835 
 32836 
 32837 /* EXPORT for RIF:
 32838    Erase the current text line from the nominal cursor position
 32839    (inclusive) to pixel column TO_X (exclusive).  The idea is that
 32840    everything from TO_X onward is already erased.
 32841 
 32842    TO_X is a pixel position relative to UPDATED_AREA of currently
 32843    updated window W.  TO_X == -1 means clear to the end of this area.  */
 32844 
 32845 void
 32846 gui_clear_end_of_line (struct window *w, struct glyph_row *updated_row,
 32847                        enum glyph_row_area updated_area, int to_x)
 32848 {
 32849   struct frame *f;
 32850   int max_x, min_y, max_y;
 32851   int from_x, from_y, to_y;
 32852   struct face *face;
 32853 
 32854   eassert (updated_row);
 32855   f = XFRAME (w->frame);
 32856   face = FACE_FROM_ID_OR_NULL (f, DEFAULT_FACE_ID);
 32857 
 32858   if (updated_row->full_width_p)
 32859     max_x = (WINDOW_PIXEL_WIDTH (w)
 32860              - (updated_row->mode_line_p ? WINDOW_RIGHT_DIVIDER_WIDTH (w) : 0));
 32861   else
 32862     max_x = window_box_width (w, updated_area);
 32863   max_y = window_text_bottom_y (w);
 32864 
 32865   /* TO_X == 0 means don't do anything.  TO_X < 0 means clear to end
 32866      of window.  For TO_X > 0, truncate to end of drawing area.  */
 32867   if (to_x == 0)
 32868     return;
 32869   else if (to_x < 0)
 32870     to_x = max_x;
 32871   else
 32872     to_x = min (to_x, max_x);
 32873 
 32874   to_y = min (max_y, w->output_cursor.y + updated_row->height);
 32875 
 32876   /* Notice if the cursor will be cleared by this operation.  */
 32877   if (!updated_row->full_width_p)
 32878     notice_overwritten_cursor (w, updated_area,
 32879                                w->output_cursor.x, -1,
 32880                                updated_row->y,
 32881                                MATRIX_ROW_BOTTOM_Y (updated_row));
 32882 
 32883   from_x = w->output_cursor.x;
 32884 
 32885   /* Translate to frame coordinates.  */
 32886   if (updated_row->full_width_p)
 32887     {
 32888       from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
 32889       to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
 32890     }
 32891   else
 32892     {
 32893       int area_left = window_box_left (w, updated_area);
 32894       from_x += area_left;
 32895       to_x += area_left;
 32896     }
 32897 
 32898   min_y = WINDOW_TAB_LINE_HEIGHT (w) + WINDOW_HEADER_LINE_HEIGHT (w);
 32899   from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, w->output_cursor.y));
 32900   to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
 32901 
 32902   /* Prevent inadvertently clearing to end of the X window.  */
 32903   if (to_x > from_x && to_y > from_y)
 32904     {
 32905       block_input ();
 32906       FRAME_RIF (f)->clear_frame_area (f, from_x, from_y,
 32907                                        to_x - from_x, to_y - from_y);
 32908 
 32909       if (face && !updated_row->stipple_p)
 32910         updated_row->stipple_p = face->stipple;
 32911       unblock_input ();
 32912     }
 32913 }
 32914 
 32915 #endif /* HAVE_WINDOW_SYSTEM */
 32916 
 32917 
 32918 
 32919 /***********************************************************************
 32920                              Cursor types
 32921  ***********************************************************************/
 32922 
 32923 /* Value is the internal representation of the specified cursor type
 32924    ARG.  If type is BAR_CURSOR, return in *WIDTH the specified width
 32925    of the bar cursor.  */
 32926 
 32927 static enum text_cursor_kinds
 32928 get_specified_cursor_type (Lisp_Object arg, int *width)
 32929 {
 32930   enum text_cursor_kinds type;
 32931 
 32932   if (NILP (arg))
 32933     return NO_CURSOR;
 32934 
 32935   if (EQ (arg, Qbox))
 32936     return FILLED_BOX_CURSOR;
 32937 
 32938   if (EQ (arg, Qhollow))
 32939     return HOLLOW_BOX_CURSOR;
 32940 
 32941   if (EQ (arg, Qbar))
 32942     {
 32943       *width = 2;
 32944       return BAR_CURSOR;
 32945     }
 32946 
 32947   if (EQ (arg, Qhbar))
 32948     {
 32949       *width = 2;
 32950       return HBAR_CURSOR;
 32951     }
 32952 
 32953   if (CONSP (arg)
 32954       && RANGED_FIXNUMP (0, XCDR (arg), INT_MAX))
 32955     {
 32956       *width = XFIXNUM (XCDR (arg));
 32957 
 32958       if (EQ (XCAR (arg), Qbox))
 32959           return FILLED_BOX_CURSOR;
 32960       else if (EQ (XCAR (arg), Qbar))
 32961           return BAR_CURSOR;
 32962       else if (EQ (XCAR (arg), Qhbar))
 32963           return HBAR_CURSOR;
 32964     }
 32965 
 32966   /* Treat anything unknown as "hollow box cursor".
 32967      It was bad to signal an error; people have trouble fixing
 32968      .Xdefaults with Emacs, when it has something bad in it.  */
 32969   type = HOLLOW_BOX_CURSOR;
 32970 
 32971   return type;
 32972 }
 32973 
 32974 /* Set the default cursor types for specified frame.  */
 32975 void
 32976 set_frame_cursor_types (struct frame *f, Lisp_Object arg)
 32977 {
 32978   int width = 1;
 32979   Lisp_Object tem;
 32980 
 32981   FRAME_DESIRED_CURSOR (f) = get_specified_cursor_type (arg, &width);
 32982   FRAME_CURSOR_WIDTH (f) = width;
 32983 
 32984   /* By default, set up the blink-off state depending on the on-state.  */
 32985 
 32986   tem = Fassoc (arg, Vblink_cursor_alist, Qnil);
 32987   if (!NILP (tem))
 32988     {
 32989       FRAME_BLINK_OFF_CURSOR (f)
 32990         = get_specified_cursor_type (XCDR (tem), &width);
 32991       FRAME_BLINK_OFF_CURSOR_WIDTH (f) = width;
 32992     }
 32993   else
 32994     FRAME_BLINK_OFF_CURSOR (f) = DEFAULT_CURSOR;
 32995 
 32996   /* Make sure the cursor gets redrawn.  */
 32997   f->cursor_type_changed = true;
 32998 }
 32999 
 33000 
 33001 #ifdef HAVE_WINDOW_SYSTEM
 33002 
 33003 /* Return the cursor we want to be displayed in window W.  Return
 33004    width of bar/hbar cursor through WIDTH arg.  Return with
 33005    ACTIVE_CURSOR arg set to true if cursor in window W is `active'
 33006    (i.e. if the `system caret' should track this cursor).
 33007 
 33008    In a mini-buffer window, we want the cursor only to appear if we
 33009    are reading input from this window.  For the selected window, we
 33010    want the cursor type given by the frame parameter or buffer local
 33011    setting of cursor-type.  If explicitly marked off, draw no cursor.
 33012    In all other cases, we want a hollow box cursor.  */
 33013 
 33014 static enum text_cursor_kinds
 33015 get_window_cursor_type (struct window *w, struct glyph *glyph, int *width,
 33016                         bool *active_cursor)
 33017 {
 33018   struct frame *f = XFRAME (w->frame);
 33019   struct buffer *b = XBUFFER (w->contents);
 33020   int cursor_type = DEFAULT_CURSOR;
 33021   Lisp_Object alt_cursor;
 33022   bool non_selected = false;
 33023 
 33024   *active_cursor = true;
 33025 
 33026   /* Echo area */
 33027   if (cursor_in_echo_area
 33028       && FRAME_HAS_MINIBUF_P (f)
 33029       && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
 33030     {
 33031       if (w == XWINDOW (echo_area_window))
 33032         {
 33033           if (EQ (BVAR (b, cursor_type), Qt) || NILP (BVAR (b, cursor_type)))
 33034             {
 33035               *width = FRAME_CURSOR_WIDTH (f);
 33036               return FRAME_DESIRED_CURSOR (f);
 33037             }
 33038           else
 33039             return get_specified_cursor_type (BVAR (b, cursor_type), width);
 33040         }
 33041 
 33042       *active_cursor = false;
 33043       non_selected = true;
 33044     }
 33045 
 33046   /* Detect a nonselected window or nonselected frame.  */
 33047   else if (w != XWINDOW (f->selected_window)
 33048            || f != FRAME_DISPLAY_INFO (f)->highlight_frame)
 33049     {
 33050       *active_cursor = false;
 33051 
 33052       if (MINI_WINDOW_P (w) &&
 33053           (minibuf_level == 0
 33054            || is_minibuffer (0, w->contents)))
 33055         return NO_CURSOR;
 33056 
 33057       non_selected = true;
 33058     }
 33059 
 33060   /* Never display a cursor in a window in which cursor-type is nil.  */
 33061   if (NILP (BVAR (b, cursor_type)))
 33062     return NO_CURSOR;
 33063 
 33064   /* Get the normal cursor type for this window.  */
 33065   if (EQ (BVAR (b, cursor_type), Qt))
 33066     {
 33067       cursor_type = FRAME_DESIRED_CURSOR (f);
 33068       *width = FRAME_CURSOR_WIDTH (f);
 33069     }
 33070   else
 33071     cursor_type = get_specified_cursor_type (BVAR (b, cursor_type), width);
 33072 
 33073   /* Use cursor-in-non-selected-windows instead
 33074      for non-selected window or frame.  */
 33075   if (non_selected)
 33076     {
 33077       alt_cursor = BVAR (b, cursor_in_non_selected_windows);
 33078       if (!EQ (Qt, alt_cursor))
 33079         return get_specified_cursor_type (alt_cursor, width);
 33080       /* t means modify the normal cursor type.  */
 33081       if (cursor_type == FILLED_BOX_CURSOR)
 33082         cursor_type = HOLLOW_BOX_CURSOR;
 33083       else if (cursor_type == BAR_CURSOR && *width > 1)
 33084         --*width;
 33085       return cursor_type;
 33086     }
 33087 
 33088   /* Use normal cursor if not blinked off.  */
 33089   if (!w->cursor_off_p)
 33090     {
 33091       if (glyph != NULL && glyph->type == XWIDGET_GLYPH)
 33092         return NO_CURSOR;
 33093       if (glyph != NULL && glyph->type == IMAGE_GLYPH)
 33094         {
 33095           if (cursor_type == FILLED_BOX_CURSOR)
 33096             {
 33097               /* Using a block cursor on large images can be very
 33098                  annoying.  So use a hollow cursor for "large" images.
 33099                  If image is not transparent (no mask), also use
 33100                  hollow cursor.  */
 33101               struct image *img = IMAGE_OPT_FROM_ID (f, glyph->u.img_id);
 33102               if (img != NULL && IMAGEP (img->spec))
 33103                 {
 33104                   /* Interpret "large" as >SIZExSIZE and >NxN where
 33105                      SIZE is the value from cursor-type of the form
 33106                      (box . SIZE), where N = size of default frame
 33107                      font size.  So, setting cursor-type to (box . 32)
 33108                      should cover most of the "tiny" icons people may
 33109                      use.  */
 33110                   if (!img->mask
 33111                       || (CONSP (BVAR (b, cursor_type))
 33112                           && img->width > max (*width, WINDOW_FRAME_COLUMN_WIDTH (w))
 33113                           && img->height > max (*width, WINDOW_FRAME_LINE_HEIGHT (w))))
 33114                     cursor_type = HOLLOW_BOX_CURSOR;
 33115                 }
 33116             }
 33117           else if (cursor_type != NO_CURSOR)
 33118             {
 33119               /* Display current only supports BOX and HOLLOW cursors for images.
 33120                  So for now, unconditionally use a HOLLOW cursor when cursor is
 33121                  not a solid box cursor.  */
 33122               cursor_type = HOLLOW_BOX_CURSOR;
 33123             }
 33124       }
 33125       return cursor_type;
 33126     }
 33127 
 33128   /* Cursor is blinked off, so determine how to "toggle" it.  */
 33129 
 33130   /* First look for an entry matching the buffer's cursor-type in blink-cursor-alist.  */
 33131   if ((alt_cursor = Fassoc (BVAR (b, cursor_type), Vblink_cursor_alist, Qnil), !NILP (alt_cursor)))
 33132     return get_specified_cursor_type (XCDR (alt_cursor), width);
 33133 
 33134   /* Then see if frame has specified a specific blink off cursor type.  */
 33135   if (FRAME_BLINK_OFF_CURSOR (f) != DEFAULT_CURSOR)
 33136     {
 33137       *width = FRAME_BLINK_OFF_CURSOR_WIDTH (f);
 33138       return FRAME_BLINK_OFF_CURSOR (f);
 33139     }
 33140 
 33141 #if false
 33142   /* Some people liked having a permanently visible blinking cursor,
 33143      while others had very strong opinions against it.  So it was
 33144      decided to remove it.  KFS 2003-09-03 */
 33145 
 33146   /* Finally perform built-in cursor blinking:
 33147        filled box      <->   hollow box
 33148        wide [h]bar     <->   narrow [h]bar
 33149        narrow [h]bar   <->   no cursor
 33150        other type      <->   no cursor  */
 33151 
 33152   if (cursor_type == FILLED_BOX_CURSOR)
 33153     return HOLLOW_BOX_CURSOR;
 33154 
 33155   if ((cursor_type == BAR_CURSOR || cursor_type == HBAR_CURSOR) && *width > 1)
 33156     {
 33157       *width = 1;
 33158       return cursor_type;
 33159     }
 33160 #endif
 33161 
 33162   return NO_CURSOR;
 33163 }
 33164 
 33165 
 33166 /* Notice when the text cursor of window W has been completely
 33167    overwritten by a drawing operation that outputs glyphs in AREA
 33168    starting at X0 and ending at X1 in the line starting at Y0 and
 33169    ending at Y1.  X coordinates are area-relative.  X1 < 0 means all
 33170    the rest of the line after X0 has been written.  Y coordinates
 33171    are window-relative.  */
 33172 
 33173 static void
 33174 notice_overwritten_cursor (struct window *w, enum glyph_row_area area,
 33175                            int x0, int x1, int y0, int y1)
 33176 {
 33177   int cx0, cx1, cy0, cy1;
 33178   struct glyph_row *row;
 33179 
 33180   if (!w->phys_cursor_on_p)
 33181     return;
 33182   if (area != TEXT_AREA)
 33183     return;
 33184 
 33185   if (w->phys_cursor.vpos < 0
 33186       || w->phys_cursor.vpos >= w->current_matrix->nrows
 33187       || (row = w->current_matrix->rows + w->phys_cursor.vpos,
 33188           !(row->enabled_p && MATRIX_ROW_DISPLAYS_TEXT_P (row))))
 33189     return;
 33190 
 33191   if (row->cursor_in_fringe_p)
 33192     {
 33193       row->cursor_in_fringe_p = false;
 33194       draw_fringe_bitmap (w, row, row->reversed_p);
 33195       w->phys_cursor_on_p = false;
 33196       return;
 33197     }
 33198 
 33199   cx0 = w->phys_cursor.x;
 33200   cx1 = cx0 + w->phys_cursor_width;
 33201   if (x0 > cx0 || (x1 >= 0 && x1 < cx1))
 33202     return;
 33203 
 33204   /* The cursor image will be completely removed from the
 33205      screen if the output area intersects the cursor area in
 33206      y-direction.  When we draw in [y0 y1[, and some part of
 33207      the cursor is at y < y0, that part must have been drawn
 33208      before.  When scrolling, the cursor is erased before
 33209      actually scrolling, so we don't come here.  When not
 33210      scrolling, the rows above the old cursor row must have
 33211      changed, and in this case these rows must have written
 33212      over the cursor image.
 33213 
 33214      Likewise if part of the cursor is below y1, with the
 33215      exception of the cursor being in the first blank row at
 33216      the buffer and window end because update_text_area
 33217      doesn't draw that row.  (Except when it does, but
 33218      that's handled in update_text_area.)  */
 33219 
 33220   cy0 = w->phys_cursor.y;
 33221   cy1 = cy0 + w->phys_cursor_height;
 33222   if ((y0 < cy0 || y0 >= cy1) && (y1 <= cy0 || y1 >= cy1))
 33223     return;
 33224 
 33225   w->phys_cursor_on_p = false;
 33226 }
 33227 
 33228 #endif /* HAVE_WINDOW_SYSTEM */
 33229 
 33230 
 33231 /************************************************************************
 33232                               Mouse Face
 33233  ************************************************************************/
 33234 
 33235 #ifdef HAVE_WINDOW_SYSTEM
 33236 
 33237 /* EXPORT for RIF:
 33238    Fix the display of area AREA of overlapping row ROW in window W
 33239    with respect to the overlapping part OVERLAPS.  */
 33240 
 33241 void
 33242 gui_fix_overlapping_area (struct window *w, struct glyph_row *row,
 33243                         enum glyph_row_area area, int overlaps)
 33244 {
 33245   int i, x;
 33246 
 33247   block_input ();
 33248 
 33249   x = 0;
 33250   for (i = 0; i < row->used[area];)
 33251     {
 33252       if (row->glyphs[area][i].overlaps_vertically_p)
 33253         {
 33254           int start = i, start_x = x;
 33255 
 33256           do
 33257             {
 33258               x += row->glyphs[area][i].pixel_width;
 33259               ++i;
 33260             }
 33261           while (i < row->used[area]
 33262                  && row->glyphs[area][i].overlaps_vertically_p);
 33263 
 33264           draw_glyphs (w, start_x, row, area,
 33265                        start, i,
 33266                        DRAW_NORMAL_TEXT, overlaps);
 33267         }
 33268       else
 33269         {
 33270           x += row->glyphs[area][i].pixel_width;
 33271           ++i;
 33272         }
 33273     }
 33274 
 33275   unblock_input ();
 33276 }
 33277 
 33278 
 33279 /* EXPORT:
 33280    Draw the cursor glyph of window W in glyph row ROW.  See the
 33281    comment of draw_glyphs for the meaning of HL.  */
 33282 
 33283 void
 33284 draw_phys_cursor_glyph (struct window *w, struct glyph_row *row,
 33285                         enum draw_glyphs_face hl)
 33286 {
 33287   /* If cursor hpos is out of bounds, don't draw garbage.  This can
 33288      happen in mini-buffer windows when switching between echo area
 33289      glyphs and mini-buffer.  */
 33290   if ((row->reversed_p
 33291        ? (w->phys_cursor.hpos >= 0)
 33292        : (w->phys_cursor.hpos < row->used[TEXT_AREA])))
 33293     {
 33294       bool on_p = w->phys_cursor_on_p;
 33295       int x1;
 33296       int hpos = w->phys_cursor.hpos;
 33297 
 33298       /* When the window is hscrolled, cursor hpos can legitimately be
 33299          out of bounds, but we draw the cursor at the corresponding
 33300          window margin in that case.  */
 33301       if (!row->reversed_p && hpos < 0)
 33302         hpos = 0;
 33303       if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 33304         hpos = row->used[TEXT_AREA] - 1;
 33305 
 33306       x1 = draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA, hpos, hpos + 1,
 33307                         hl, 0);
 33308       w->phys_cursor_on_p = on_p;
 33309 
 33310       if (hl == DRAW_CURSOR)
 33311         w->phys_cursor_width = x1 - w->phys_cursor.x;
 33312       /* When we erase the cursor, and ROW is overlapped by other
 33313          rows, make sure that these overlapping parts of other rows
 33314          are redrawn.  */
 33315       else if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
 33316         {
 33317           w->phys_cursor_width = x1 - w->phys_cursor.x;
 33318 
 33319           if (row > w->current_matrix->rows
 33320               && MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
 33321             gui_fix_overlapping_area (w, row - 1, TEXT_AREA,
 33322                                     OVERLAPS_ERASED_CURSOR);
 33323 
 33324           if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
 33325               && MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
 33326             gui_fix_overlapping_area (w, row + 1, TEXT_AREA,
 33327                                     OVERLAPS_ERASED_CURSOR);
 33328         }
 33329     }
 33330 }
 33331 
 33332 
 33333 /* Erase the image of a cursor of window W from the screen.  */
 33334 
 33335 void
 33336 erase_phys_cursor (struct window *w)
 33337 {
 33338   struct frame *f = XFRAME (w->frame);
 33339   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 33340   int hpos = w->phys_cursor.hpos;
 33341   int vpos = w->phys_cursor.vpos;
 33342   bool mouse_face_here_p = false;
 33343   struct glyph_matrix *active_glyphs = w->current_matrix;
 33344   struct glyph_row *cursor_row;
 33345   struct glyph *cursor_glyph;
 33346   enum draw_glyphs_face hl;
 33347 
 33348   /* No cursor displayed or row invalidated => nothing to do on the
 33349      screen.  */
 33350   if (w->phys_cursor_type == NO_CURSOR)
 33351     goto mark_cursor_off;
 33352 
 33353   /* VPOS >= active_glyphs->nrows means that window has been resized.
 33354      Don't bother to erase the cursor.  */
 33355   if (vpos >= active_glyphs->nrows)
 33356     goto mark_cursor_off;
 33357 
 33358   /* If row containing cursor is marked invalid, there is nothing we
 33359      can do.  */
 33360   cursor_row = MATRIX_ROW (active_glyphs, vpos);
 33361   if (!cursor_row->enabled_p)
 33362     goto mark_cursor_off;
 33363 
 33364   /* If line spacing is > 0, old cursor may only be partially visible in
 33365      window after split-window.  So adjust visible height.  */
 33366   cursor_row->visible_height = min (cursor_row->visible_height,
 33367                                     window_text_bottom_y (w) - cursor_row->y);
 33368 
 33369   /* If row is completely invisible, don't attempt to delete a cursor which
 33370      isn't there.  This can happen if cursor is at top of a window, and
 33371      we switch to a buffer with a header line in that window.  */
 33372   if (cursor_row->visible_height <= 0)
 33373     goto mark_cursor_off;
 33374 
 33375   /* If cursor is in the fringe, erase by drawing actual bitmap there.  */
 33376   if (cursor_row->cursor_in_fringe_p)
 33377     {
 33378       cursor_row->cursor_in_fringe_p = false;
 33379       draw_fringe_bitmap (w, cursor_row, cursor_row->reversed_p);
 33380       goto mark_cursor_off;
 33381     }
 33382 
 33383   /* This can happen when the new row is shorter than the old one.
 33384      In this case, either draw_glyphs or clear_end_of_line
 33385      should have cleared the cursor.  Note that we wouldn't be
 33386      able to erase the cursor in this case because we don't have a
 33387      cursor glyph at hand.  */
 33388   if ((cursor_row->reversed_p
 33389        ? (w->phys_cursor.hpos < 0)
 33390        : (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])))
 33391     goto mark_cursor_off;
 33392 
 33393   /* When the window is hscrolled, cursor hpos can legitimately be out
 33394      of bounds, but we draw the cursor at the corresponding window
 33395      margin in that case.  */
 33396   if (!cursor_row->reversed_p && hpos < 0)
 33397     hpos = 0;
 33398   if (cursor_row->reversed_p && hpos >= cursor_row->used[TEXT_AREA])
 33399     hpos = cursor_row->used[TEXT_AREA] - 1;
 33400 
 33401   /* If the cursor is in the mouse face area, redisplay that when
 33402      we clear the cursor.  */
 33403   if (! NILP (hlinfo->mouse_face_window)
 33404       && coords_in_mouse_face_p (w, hpos, vpos)
 33405       /* Don't redraw the cursor's spot in mouse face if it is at the
 33406          end of a line (on a newline).  The cursor appears there, but
 33407          mouse highlighting does not.  */
 33408       && cursor_row->used[TEXT_AREA] > hpos && hpos >= 0)
 33409     mouse_face_here_p = true;
 33410 
 33411 #ifdef HAVE_WINDOW_SYSTEM
 33412   /* Since erasing the phys cursor will probably lead to corruption of
 33413      the mouse face display if the glyph's pixel_width is not kept up
 33414      to date with the :box property of the mouse face, just redraw the
 33415      mouse face.  */
 33416   if (FRAME_WINDOW_P (WINDOW_XFRAME (w)) && mouse_face_here_p)
 33417     {
 33418       w->phys_cursor_on_p = false;
 33419       w->phys_cursor_type = NO_CURSOR;
 33420       show_mouse_face (MOUSE_HL_INFO (WINDOW_XFRAME (w)), DRAW_MOUSE_FACE);
 33421       return;
 33422     }
 33423 #endif
 33424 
 33425   /* Maybe clear the display under the cursor.  */
 33426   if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
 33427     {
 33428       int x, y;
 33429       int tab_line_height = WINDOW_TAB_LINE_HEIGHT (w);
 33430       int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
 33431       int width;
 33432 
 33433       cursor_glyph = get_phys_cursor_glyph (w);
 33434       if (cursor_glyph == NULL)
 33435         goto mark_cursor_off;
 33436 
 33437       width = cursor_glyph->pixel_width;
 33438       x = w->phys_cursor.x;
 33439       if (x < 0)
 33440         {
 33441           width += x;
 33442           x = 0;
 33443         }
 33444       width = min (width, window_box_width (w, TEXT_AREA) - x);
 33445       y = WINDOW_TO_FRAME_PIXEL_Y (w, max (tab_line_height, max (header_line_height, cursor_row->y)));
 33446       x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, x);
 33447 
 33448       if (width > 0)
 33449         FRAME_RIF (f)->clear_frame_area (f, x, y, width, cursor_row->visible_height);
 33450     }
 33451 
 33452   /* Erase the cursor by redrawing the character underneath it.  */
 33453   if (mouse_face_here_p)
 33454     hl = DRAW_MOUSE_FACE;
 33455   else
 33456     hl = DRAW_NORMAL_TEXT;
 33457   draw_phys_cursor_glyph (w, cursor_row, hl);
 33458 
 33459  mark_cursor_off:
 33460   w->phys_cursor_on_p = false;
 33461   w->phys_cursor_type = NO_CURSOR;
 33462 }
 33463 
 33464 
 33465 /* Display or clear cursor of window W.  If !ON, clear the cursor.
 33466    If ON, display the cursor; where to put the cursor is specified by
 33467    HPOS, VPOS, X and Y.  */
 33468 
 33469 void
 33470 display_and_set_cursor (struct window *w, bool on,
 33471                         int hpos, int vpos, int x, int y)
 33472 {
 33473   struct frame *f = XFRAME (w->frame);
 33474   int new_cursor_type;
 33475   int new_cursor_width UNINIT;
 33476   bool active_cursor;
 33477   struct glyph_row *glyph_row;
 33478   struct glyph *glyph;
 33479 
 33480   /* This is pointless on invisible frames, and dangerous on garbaged
 33481      windows and frames; in the latter case, the frame or window may
 33482      be in the midst of changing its size, and x and y may be off the
 33483      window.  */
 33484   if (! FRAME_REDISPLAY_P (f)
 33485       || vpos >= w->current_matrix->nrows
 33486       || hpos >= w->current_matrix->matrix_w)
 33487     return;
 33488 
 33489   /* If cursor is off and we want it off, return quickly.  */
 33490   if (!on && !w->phys_cursor_on_p)
 33491     return;
 33492 
 33493   glyph_row = MATRIX_ROW (w->current_matrix, vpos);
 33494   /* If cursor row is not enabled, we don't really know where to
 33495      display the cursor.  */
 33496   if (!glyph_row->enabled_p)
 33497     {
 33498       w->phys_cursor_on_p = false;
 33499       return;
 33500     }
 33501 
 33502   /* A frame might be marked garbaged even though its cursor position
 33503      is correct, and will not change upon subsequent redisplay.  This
 33504      happens in some rare situations, like toggling the sort order in
 33505      Dired windows.  We've already established that VPOS is valid, so
 33506      it shouldn't do any harm to record the cursor position, as we are
 33507      going to return without acting on it anyway.  Otherwise, expose
 33508      events might come in and call update_window_cursor, which will
 33509      blindly use outdated values in w->phys_cursor.  */
 33510   if (FRAME_GARBAGED_P (f))
 33511     {
 33512       if (on)
 33513         {
 33514           w->phys_cursor.x = x;
 33515           w->phys_cursor.y = glyph_row->y;
 33516           w->phys_cursor.hpos = hpos;
 33517           w->phys_cursor.vpos = vpos;
 33518         }
 33519       return;
 33520     }
 33521 
 33522   glyph = NULL;
 33523   if (0 <= hpos && hpos < glyph_row->used[TEXT_AREA])
 33524     glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
 33525 
 33526   eassert (input_blocked_p ());
 33527 
 33528   /* Set new_cursor_type to the cursor we want to be displayed.  */
 33529   new_cursor_type = get_window_cursor_type (w, glyph,
 33530                                             &new_cursor_width, &active_cursor);
 33531 
 33532   /* If cursor is currently being shown and we don't want it to be or
 33533      it is in the wrong place, or the cursor type is not what we want,
 33534      erase it.  */
 33535   if (w->phys_cursor_on_p
 33536       && (!on
 33537           || w->phys_cursor.x != x
 33538           || w->phys_cursor.y != y
 33539           /* HPOS can be negative in R2L rows whose
 33540              exact_window_width_line_p flag is set (i.e. their newline
 33541              would "overflow into the fringe").  */
 33542           || hpos < 0
 33543           || new_cursor_type != w->phys_cursor_type
 33544           || ((new_cursor_type == BAR_CURSOR || new_cursor_type == HBAR_CURSOR)
 33545               && new_cursor_width != w->phys_cursor_width)))
 33546     erase_phys_cursor (w);
 33547 
 33548   /* Don't check phys_cursor_on_p here because that flag is only set
 33549      to false in some cases where we know that the cursor has been
 33550      completely erased, to avoid the extra work of erasing the cursor
 33551      twice.  In other words, phys_cursor_on_p can be true and the cursor
 33552      still not be visible, or it has only been partly erased.  */
 33553   if (on)
 33554     {
 33555       w->phys_cursor_ascent = glyph_row->ascent;
 33556       w->phys_cursor_height = glyph_row->height;
 33557 
 33558       /* Set phys_cursor_.* before x_draw_.* is called because some
 33559          of them may need the information.  */
 33560       w->phys_cursor.x = x;
 33561       w->phys_cursor.y = glyph_row->y;
 33562       w->phys_cursor.hpos = hpos;
 33563       w->phys_cursor.vpos = vpos;
 33564     }
 33565 
 33566   FRAME_RIF (f)->draw_window_cursor (w, glyph_row, x, y,
 33567                                      new_cursor_type, new_cursor_width,
 33568                                      on, active_cursor);
 33569 }
 33570 
 33571 
 33572 /* Switch the display of W's cursor on or off, according to the value
 33573    of ON.  */
 33574 
 33575 static void
 33576 update_window_cursor (struct window *w, bool on)
 33577 {
 33578   /* Don't update cursor in windows whose frame is in the process
 33579      of being deleted.  */
 33580   if (w->current_matrix)
 33581     {
 33582       int hpos = w->phys_cursor.hpos;
 33583       int vpos = w->phys_cursor.vpos;
 33584       struct glyph_row *row;
 33585 
 33586       if (vpos >= w->current_matrix->nrows
 33587           || hpos >= w->current_matrix->matrix_w)
 33588         return;
 33589 
 33590       row = MATRIX_ROW (w->current_matrix, vpos);
 33591 
 33592       /* When the window is hscrolled, cursor hpos can legitimately be
 33593          out of bounds, but we draw the cursor at the corresponding
 33594          window margin in that case.  */
 33595       if (!row->reversed_p && hpos < 0)
 33596         hpos = 0;
 33597       if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 33598         hpos = row->used[TEXT_AREA] - 1;
 33599 
 33600       block_input ();
 33601       display_and_set_cursor (w, on, hpos, vpos,
 33602                               w->phys_cursor.x, w->phys_cursor.y);
 33603       unblock_input ();
 33604     }
 33605 }
 33606 
 33607 
 33608 /* Call update_window_cursor with parameter ON_P on all leaf windows
 33609    in the window tree rooted at W.  */
 33610 
 33611 static void
 33612 update_cursor_in_window_tree (struct window *w, bool on_p)
 33613 {
 33614   while (w)
 33615     {
 33616       if (WINDOWP (w->contents))
 33617         update_cursor_in_window_tree (XWINDOW (w->contents), on_p);
 33618       else
 33619         update_window_cursor (w, on_p);
 33620 
 33621       w = NILP (w->next) ? 0 : XWINDOW (w->next);
 33622     }
 33623 }
 33624 
 33625 
 33626 /* EXPORT:
 33627    Display the cursor on window W, or clear it, according to ON_P.
 33628    Don't change the cursor's position.  */
 33629 
 33630 void
 33631 gui_update_cursor (struct frame *f, bool on_p)
 33632 {
 33633   update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
 33634 }
 33635 
 33636 
 33637 /* EXPORT:
 33638    Clear the cursor of window W to background color, and mark the
 33639    cursor as not shown.  This is used when the text where the cursor
 33640    is about to be rewritten.  */
 33641 
 33642 void
 33643 gui_clear_cursor (struct window *w)
 33644 {
 33645   if (FRAME_REDISPLAY_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
 33646     update_window_cursor (w, false);
 33647 }
 33648 
 33649 #endif /* HAVE_WINDOW_SYSTEM */
 33650 
 33651 /* Implementation of draw_row_with_mouse_face for GUI sessions, GPM,
 33652    and MSDOS.  */
 33653 static void
 33654 draw_row_with_mouse_face (struct window *w, int start_x, struct glyph_row *row,
 33655                           int start_hpos, int end_hpos,
 33656                           enum draw_glyphs_face draw)
 33657 {
 33658 #ifdef HAVE_WINDOW_SYSTEM
 33659   if (FRAME_WINDOW_P (XFRAME (w->frame)))
 33660     {
 33661       draw_glyphs (w, start_x, row, TEXT_AREA, start_hpos, end_hpos, draw, 0);
 33662       return;
 33663     }
 33664 #endif
 33665 
 33666   tty_draw_row_with_mouse_face (w, row, start_hpos, end_hpos, draw);
 33667 }
 33668 
 33669 /* Display the active region described by mouse_face_* according to DRAW.  */
 33670 
 33671 static void
 33672 show_mouse_face (Mouse_HLInfo *hlinfo, enum draw_glyphs_face draw)
 33673 {
 33674   /* Don't bother doing anything if the mouse-face window is not set
 33675      up.  */
 33676   if (!WINDOWP (hlinfo->mouse_face_window))
 33677     return;
 33678 
 33679   struct window *w = XWINDOW (hlinfo->mouse_face_window);
 33680   struct frame *f = XFRAME (WINDOW_FRAME (w));
 33681 
 33682   /* Don't bother doing anything if we are on a wrong frame.  */
 33683   if (f != hlinfo->mouse_face_mouse_frame)
 33684     return;
 33685 
 33686   if (/* If window is in the process of being destroyed, don't bother
 33687          to do anything.  */
 33688       w->current_matrix != NULL
 33689       /* Don't update mouse highlight if hidden.  */
 33690       && (draw != DRAW_MOUSE_FACE || !hlinfo->mouse_face_hidden)
 33691       /* Recognize when we are called to operate on rows that don't exist
 33692          anymore.  This can happen when a window is split.  */
 33693       && hlinfo->mouse_face_end_row < w->current_matrix->nrows)
 33694     {
 33695       bool phys_cursor_on_p = w->phys_cursor_on_p;
 33696 #ifdef HAVE_WINDOW_SYSTEM
 33697       int mouse_off = 0;
 33698 #endif
 33699       struct glyph_row *row, *first, *last;
 33700 
 33701       first = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_beg_row);
 33702       last = MATRIX_ROW (w->current_matrix, hlinfo->mouse_face_end_row);
 33703 
 33704       for (row = first; row <= last && row->enabled_p; ++row)
 33705         {
 33706           int start_hpos, end_hpos, start_x;
 33707 
 33708           /* For all but the first row, the highlight starts at column 0.  */
 33709           if (row == first)
 33710             {
 33711               /* R2L rows have BEG and END in reversed order, but the
 33712                  screen drawing geometry is always left to right.  So
 33713                  we need to mirror the beginning and end of the
 33714                  highlighted area in R2L rows.  */
 33715               if (!row->reversed_p)
 33716                 {
 33717                   start_hpos = hlinfo->mouse_face_beg_col;
 33718                   start_x = hlinfo->mouse_face_beg_x;
 33719                 }
 33720               else if (row == last)
 33721                 {
 33722                   start_hpos = hlinfo->mouse_face_end_col;
 33723                   start_x = hlinfo->mouse_face_end_x;
 33724                 }
 33725               else
 33726                 {
 33727                   start_hpos = 0;
 33728                   start_x = 0;
 33729                 }
 33730             }
 33731           else if (row->reversed_p && row == last)
 33732             {
 33733               start_hpos = hlinfo->mouse_face_end_col;
 33734               start_x = hlinfo->mouse_face_end_x;
 33735             }
 33736           else
 33737             {
 33738               start_hpos = 0;
 33739               start_x = 0;
 33740             }
 33741 
 33742           if (row == last)
 33743             {
 33744               if (!row->reversed_p)
 33745                 end_hpos = hlinfo->mouse_face_end_col;
 33746               else if (row == first)
 33747                 end_hpos = hlinfo->mouse_face_beg_col;
 33748               else
 33749                 {
 33750                   end_hpos = row->used[TEXT_AREA];
 33751                   if (draw == DRAW_NORMAL_TEXT)
 33752                     row->fill_line_p = true; /* Clear to end of line.  */
 33753                 }
 33754             }
 33755           else if (row->reversed_p && row == first)
 33756             end_hpos = hlinfo->mouse_face_beg_col;
 33757           else
 33758             {
 33759               end_hpos = row->used[TEXT_AREA];
 33760               if (draw == DRAW_NORMAL_TEXT)
 33761                 row->fill_line_p = true; /* Clear to end of line.  */
 33762             }
 33763 
 33764           if (end_hpos > start_hpos)
 33765             {
 33766               draw_row_with_mouse_face (w, start_x, row,
 33767                                         start_hpos, end_hpos, draw);
 33768 
 33769               row->mouse_face_p
 33770                 = draw == DRAW_MOUSE_FACE || draw == DRAW_IMAGE_RAISED;
 33771             }
 33772 #ifdef HAVE_WINDOW_SYSTEM
 33773           /* Compute the cursor offset due to mouse-highlight.  */
 33774           if ((MATRIX_ROW_VPOS (row, w->current_matrix) == w->phys_cursor.vpos)
 33775               /* But not when highlighting a pseudo window, such as
 33776                  the toolbar, which can't have a cursor anyway.  */
 33777               && !w->pseudo_window_p
 33778               && draw == DRAW_MOUSE_FACE)
 33779             get_cursor_offset_for_mouse_face (w, row, &mouse_off);
 33780 #endif
 33781         }
 33782 
 33783       /* When we've written over the cursor, arrange for it to
 33784          be displayed again.  */
 33785       if (FRAME_WINDOW_P (f)
 33786           && phys_cursor_on_p && !w->phys_cursor_on_p)
 33787         {
 33788 #ifdef HAVE_WINDOW_SYSTEM
 33789           int hpos = w->phys_cursor.hpos;
 33790           int old_phys_cursor_x = w->phys_cursor.x;
 33791 
 33792           /* When the window is hscrolled, cursor hpos can legitimately be
 33793              out of bounds, but we draw the cursor at the corresponding
 33794              window margin in that case.  */
 33795           if (!row->reversed_p && hpos < 0)
 33796             hpos = 0;
 33797           if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 33798             hpos = row->used[TEXT_AREA] - 1;
 33799 
 33800           block_input ();
 33801           display_and_set_cursor (w, true, hpos, w->phys_cursor.vpos,
 33802                                   w->phys_cursor.x + mouse_off,
 33803                                   w->phys_cursor.y);
 33804           /* Restore the original cursor coordinates, perhaps modified
 33805              to account for mouse-highlight.  */
 33806           w->phys_cursor.x = old_phys_cursor_x;
 33807           unblock_input ();
 33808 #endif  /* HAVE_WINDOW_SYSTEM */
 33809         }
 33810     }
 33811 
 33812 #ifdef HAVE_WINDOW_SYSTEM
 33813   /* Change the mouse cursor.  */
 33814   if (FRAME_WINDOW_P (f) && NILP (track_mouse))
 33815     {
 33816       if (draw == DRAW_NORMAL_TEXT
 33817 #ifndef HAVE_EXT_TOOL_BAR
 33818           && !EQ (hlinfo->mouse_face_window, f->tool_bar_window)
 33819 #endif
 33820           && !EQ (hlinfo->mouse_face_window, f->tab_bar_window))
 33821         FRAME_RIF (f)->define_frame_cursor (f, FRAME_OUTPUT_DATA (f)->text_cursor);
 33822       else
 33823       if (draw == DRAW_MOUSE_FACE)
 33824         FRAME_RIF (f)->define_frame_cursor (f, FRAME_OUTPUT_DATA (f)->hand_cursor);
 33825       else
 33826         FRAME_RIF (f)->define_frame_cursor (f, FRAME_OUTPUT_DATA (f)->nontext_cursor);
 33827     }
 33828 #endif  /* HAVE_WINDOW_SYSTEM */
 33829 }
 33830 
 33831 /* EXPORT:
 33832    Clear out the mouse-highlighted active region.
 33833    Redraw it un-highlighted first.  Value is true if mouse
 33834    face was actually drawn unhighlighted.  */
 33835 
 33836 bool
 33837 clear_mouse_face (Mouse_HLInfo *hlinfo)
 33838 {
 33839   bool cleared
 33840     = !hlinfo->mouse_face_hidden && !NILP (hlinfo->mouse_face_window);
 33841   if (cleared)
 33842     show_mouse_face (hlinfo, DRAW_NORMAL_TEXT);
 33843   hlinfo->mouse_face_beg_row = hlinfo->mouse_face_beg_col = -1;
 33844   hlinfo->mouse_face_end_row = hlinfo->mouse_face_end_col = -1;
 33845   hlinfo->mouse_face_window = Qnil;
 33846   hlinfo->mouse_face_overlay = Qnil;
 33847   return cleared;
 33848 }
 33849 
 33850 /* Return true if the coordinates HPOS and VPOS on windows W are
 33851    within the mouse face on that window.  */
 33852 static bool
 33853 coords_in_mouse_face_p (struct window *w, int hpos, int vpos)
 33854 {
 33855   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
 33856 
 33857   /* Quickly resolve the easy cases.  */
 33858   if (!(WINDOWP (hlinfo->mouse_face_window)
 33859         && XWINDOW (hlinfo->mouse_face_window) == w))
 33860     return false;
 33861   if (vpos < hlinfo->mouse_face_beg_row
 33862       || vpos > hlinfo->mouse_face_end_row)
 33863     return false;
 33864   if (vpos > hlinfo->mouse_face_beg_row
 33865       && vpos < hlinfo->mouse_face_end_row)
 33866     return true;
 33867 
 33868   if (!MATRIX_ROW (w->current_matrix, vpos)->reversed_p)
 33869     {
 33870       if (hlinfo->mouse_face_beg_row == hlinfo->mouse_face_end_row)
 33871         {
 33872           if (hlinfo->mouse_face_beg_col <= hpos && hpos < hlinfo->mouse_face_end_col)
 33873             return true;
 33874         }
 33875       else if ((vpos == hlinfo->mouse_face_beg_row
 33876                 && hpos >= hlinfo->mouse_face_beg_col)
 33877                || (vpos == hlinfo->mouse_face_end_row
 33878                    && hpos < hlinfo->mouse_face_end_col))
 33879         return true;
 33880     }
 33881   else
 33882     {
 33883        if (hlinfo->mouse_face_beg_row == hlinfo->mouse_face_end_row)
 33884         {
 33885           if (hlinfo->mouse_face_end_col < hpos && hpos <= hlinfo->mouse_face_beg_col)
 33886             return true;
 33887         }
 33888       else if ((vpos == hlinfo->mouse_face_beg_row
 33889                 && hpos <= hlinfo->mouse_face_beg_col)
 33890                || (vpos == hlinfo->mouse_face_end_row
 33891                    && hpos > hlinfo->mouse_face_end_col))
 33892         return true;
 33893     }
 33894   return false;
 33895 }
 33896 
 33897 
 33898 /* EXPORT:
 33899    True if physical cursor of window W is within mouse face.  */
 33900 
 33901 bool
 33902 cursor_in_mouse_face_p (struct window *w)
 33903 {
 33904   int vpos = w->phys_cursor.vpos;
 33905 
 33906   /* If the cursor is outside the matrix glyph rows, it cannot be
 33907      within the mouse face.  */
 33908   if (!(0 <= vpos && vpos < w->current_matrix->nrows))
 33909     return false;
 33910 
 33911   int hpos = w->phys_cursor.hpos;
 33912   struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
 33913 
 33914   /* When the window is hscrolled, cursor hpos can legitimately be out
 33915      of bounds, but we draw the cursor at the corresponding window
 33916      margin in that case.  */
 33917   if (!row->reversed_p && hpos < 0)
 33918     hpos = 0;
 33919   if (row->reversed_p && hpos >= row->used[TEXT_AREA])
 33920     hpos = row->used[TEXT_AREA] - 1;
 33921 
 33922   return coords_in_mouse_face_p (w, hpos, vpos);
 33923 }
 33924 
 33925 
 33926 
 33927 /* Find the glyph rows START_ROW and END_ROW of window W that display
 33928    characters between buffer positions START_CHARPOS and END_CHARPOS
 33929    (excluding END_CHARPOS).  DISP_STRING is a display string that
 33930    covers these buffer positions.  This is similar to
 33931    row_containing_pos, but is more accurate when bidi reordering makes
 33932    buffer positions change non-linearly with glyph rows.  */
 33933 static void
 33934 rows_from_pos_range (struct window *w,
 33935                      ptrdiff_t start_charpos, ptrdiff_t end_charpos,
 33936                      Lisp_Object disp_string,
 33937                      struct glyph_row **start, struct glyph_row **end)
 33938 {
 33939   struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 33940   int last_y = window_text_bottom_y (w);
 33941   struct glyph_row *row;
 33942 
 33943   *start = NULL;
 33944   *end = NULL;
 33945 
 33946   while (!first->enabled_p
 33947          && first < MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w))
 33948     first++;
 33949 
 33950   /* Find the START row.  */
 33951   for (row = first;
 33952        row->enabled_p && MATRIX_ROW_BOTTOM_Y (row) <= last_y;
 33953        row++)
 33954     {
 33955       /* A row can potentially be the START row if the range of the
 33956          characters it displays intersects the range
 33957          [START_CHARPOS..END_CHARPOS).  */
 33958       if (! ((start_charpos < MATRIX_ROW_START_CHARPOS (row)
 33959               && end_charpos < MATRIX_ROW_START_CHARPOS (row))
 33960              /* See the commentary in row_containing_pos, for the
 33961                 explanation of the complicated way to check whether
 33962                 some position is beyond the end of the characters
 33963                 displayed by a row.  */
 33964              || ((start_charpos > MATRIX_ROW_END_CHARPOS (row)
 33965                   || (start_charpos == MATRIX_ROW_END_CHARPOS (row)
 33966                       && !row->ends_at_zv_p
 33967                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row)))
 33968                  && (end_charpos > MATRIX_ROW_END_CHARPOS (row)
 33969                      || (end_charpos == MATRIX_ROW_END_CHARPOS (row)
 33970                          && !row->ends_at_zv_p
 33971                          && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (row))))))
 33972         {
 33973           /* Found a candidate row.  Now make sure at least one of the
 33974              glyphs it displays has a charpos from the range
 33975              [START_CHARPOS..END_CHARPOS).
 33976 
 33977              This is not obvious because bidi reordering could make
 33978              buffer positions of a row be 1,2,3,102,101,100, and if we
 33979              want to highlight characters in [50..60), we don't want
 33980              this row, even though [50..60) does intersect [1..103),
 33981              the range of character positions given by the row's start
 33982              and end positions.  */
 33983           struct glyph *g = row->glyphs[TEXT_AREA];
 33984           struct glyph *e = g + row->used[TEXT_AREA];
 33985 
 33986           while (g < e)
 33987             {
 33988               if (((BUFFERP (g->object) || NILP (g->object))
 33989                    && start_charpos <= g->charpos && g->charpos < end_charpos)
 33990                   /* A glyph that comes from DISP_STRING is by
 33991                      definition to be highlighted.  */
 33992                   || EQ (g->object, disp_string))
 33993                 *start = row;
 33994               g++;
 33995             }
 33996           if (*start)
 33997             break;
 33998         }
 33999     }
 34000 
 34001   /* Find the END row.  */
 34002   if (!*start
 34003       /* If the last row is partially visible, start looking for END
 34004          from that row, instead of starting from FIRST.  */
 34005       && !(row->enabled_p
 34006            && row->y < last_y && MATRIX_ROW_BOTTOM_Y (row) > last_y))
 34007     row = first;
 34008   for ( ; row->enabled_p && MATRIX_ROW_BOTTOM_Y (row) <= last_y; row++)
 34009     {
 34010       struct glyph_row *next = row + 1;
 34011       ptrdiff_t next_start = MATRIX_ROW_START_CHARPOS (next);
 34012 
 34013       if (!next->enabled_p
 34014           || next >= MATRIX_BOTTOM_TEXT_ROW (w->current_matrix, w)
 34015           /* The first row >= START whose range of displayed characters
 34016              does NOT intersect the range [START_CHARPOS..END_CHARPOS]
 34017              is the row END + 1.  */
 34018           || (start_charpos < next_start
 34019               && end_charpos < next_start)
 34020           || ((start_charpos > MATRIX_ROW_END_CHARPOS (next)
 34021                || (start_charpos == MATRIX_ROW_END_CHARPOS (next)
 34022                    && !next->ends_at_zv_p
 34023                    && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next)))
 34024               && (end_charpos > MATRIX_ROW_END_CHARPOS (next)
 34025                   || (end_charpos == MATRIX_ROW_END_CHARPOS (next)
 34026                       && !next->ends_at_zv_p
 34027                       && !MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P (next)))))
 34028         {
 34029           *end = row;
 34030           break;
 34031         }
 34032       else
 34033         {
 34034           /* If the next row's edges intersect [START_CHARPOS..END_CHARPOS],
 34035              but none of the characters it displays are in the range, it is
 34036              also END + 1. */
 34037           struct glyph *g = next->glyphs[TEXT_AREA];
 34038           struct glyph *s = g;
 34039           struct glyph *e = g + next->used[TEXT_AREA];
 34040 
 34041           while (g < e)
 34042             {
 34043               if (((BUFFERP (g->object) || NILP (g->object))
 34044                    && ((start_charpos <= g->charpos && g->charpos < end_charpos)
 34045                        /* If the buffer position of the first glyph in
 34046                           the row is equal to END_CHARPOS, it means
 34047                           the last character to be highlighted is the
 34048                           newline of ROW, and we must consider NEXT as
 34049                           END, not END+1.  */
 34050                        || (((!next->reversed_p && g == s)
 34051                             || (next->reversed_p && g == e - 1))
 34052                            && (g->charpos == end_charpos
 34053                                /* Special case for when NEXT is an
 34054                                   empty line at ZV.  */
 34055                                || (g->charpos == -1
 34056                                    && !row->ends_at_zv_p
 34057                                    && next_start == end_charpos)))))
 34058                   /* A glyph that comes from DISP_STRING is by
 34059                      definition to be highlighted.  */
 34060                   || EQ (g->object, disp_string))
 34061                 break;
 34062               g++;
 34063             }
 34064           if (g == e)
 34065             {
 34066               *end = row;
 34067               break;
 34068             }
 34069           /* The first row that ends at ZV must be the last to be
 34070              highlighted.  */
 34071           else if (next->ends_at_zv_p)
 34072             {
 34073               *end = next;
 34074               break;
 34075             }
 34076         }
 34077     }
 34078 }
 34079 
 34080 /* This function sets the mouse_face_* elements of HLINFO, assuming
 34081    the mouse cursor is on a glyph with buffer charpos MOUSE_CHARPOS in
 34082    window WINDOW.  START_CHARPOS and END_CHARPOS are buffer positions
 34083    for the overlay or run of text properties specifying the mouse
 34084    face.  BEFORE_STRING and AFTER_STRING, if non-nil, are a
 34085    before-string and after-string that must also be highlighted.
 34086    DISP_STRING, if non-nil, is a display string that may cover some
 34087    or all of the highlighted text.  */
 34088 
 34089 static void
 34090 mouse_face_from_buffer_pos (Lisp_Object window,
 34091                             Mouse_HLInfo *hlinfo,
 34092                             ptrdiff_t mouse_charpos,
 34093                             ptrdiff_t start_charpos,
 34094                             ptrdiff_t end_charpos,
 34095                             Lisp_Object before_string,
 34096                             Lisp_Object after_string,
 34097                             Lisp_Object disp_string)
 34098 {
 34099   struct window *w = XWINDOW (window);
 34100   struct glyph_row *first = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34101   struct glyph_row *r1, *r2;
 34102   struct glyph *glyph, *end;
 34103   ptrdiff_t ignore, pos;
 34104   int x;
 34105 
 34106   eassert (NILP (disp_string) || STRINGP (disp_string));
 34107   eassert (NILP (before_string) || STRINGP (before_string));
 34108   eassert (NILP (after_string) || STRINGP (after_string));
 34109 
 34110   /* Find the rows corresponding to START_CHARPOS and END_CHARPOS.  */
 34111   rows_from_pos_range (w, start_charpos, end_charpos, disp_string, &r1, &r2);
 34112   if (r1 == NULL)
 34113     r1 = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 34114   /* If the before-string or display-string contains newlines,
 34115      rows_from_pos_range skips to its last row.  Move back.  */
 34116   if (!NILP (before_string) || !NILP (disp_string))
 34117     {
 34118       struct glyph_row *prev;
 34119       while ((prev = r1 - 1, prev >= first)
 34120              && MATRIX_ROW_END_CHARPOS (prev) == start_charpos
 34121              && prev->used[TEXT_AREA] > 0)
 34122         {
 34123           struct glyph *beg = prev->glyphs[TEXT_AREA];
 34124           glyph = beg + prev->used[TEXT_AREA];
 34125           while (--glyph >= beg && NILP (glyph->object));
 34126           if (glyph < beg
 34127               || !(EQ (glyph->object, before_string)
 34128                    || EQ (glyph->object, disp_string)))
 34129             break;
 34130           r1 = prev;
 34131         }
 34132     }
 34133   if (r2 == NULL)
 34134     {
 34135       r2 = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 34136       hlinfo->mouse_face_past_end = true;
 34137     }
 34138   else if (!NILP (after_string))
 34139     {
 34140       /* If the after-string has newlines, advance to its last row.  */
 34141       struct glyph_row *next;
 34142       struct glyph_row *last
 34143         = MATRIX_ROW (w->current_matrix, w->window_end_vpos);
 34144 
 34145       for (next = r2 + 1;
 34146            next <= last
 34147              && next->used[TEXT_AREA] > 0
 34148              && EQ (next->glyphs[TEXT_AREA]->object, after_string);
 34149            ++next)
 34150         r2 = next;
 34151     }
 34152   /* The rest of the display engine assumes that mouse_face_beg_row is
 34153      either above mouse_face_end_row or identical to it.  But with
 34154      bidi-reordered continued lines, the row for START_CHARPOS could
 34155      be below the row for END_CHARPOS.  If so, swap the rows and store
 34156      them in correct order.  */
 34157   if (r1->y > r2->y)
 34158     {
 34159       struct glyph_row *tem = r2;
 34160 
 34161       r2 = r1;
 34162       r1 = tem;
 34163     }
 34164 
 34165   hlinfo->mouse_face_beg_row = MATRIX_ROW_VPOS (r1, w->current_matrix);
 34166   hlinfo->mouse_face_end_row = MATRIX_ROW_VPOS (r2, w->current_matrix);
 34167 
 34168   /* For a bidi-reordered row, the positions of BEFORE_STRING,
 34169      AFTER_STRING, DISP_STRING, START_CHARPOS, and END_CHARPOS
 34170      could be anywhere in the row and in any order.  The strategy
 34171      below is to find the leftmost and the rightmost glyph that
 34172      belongs to either of these 3 strings, or whose position is
 34173      between START_CHARPOS and END_CHARPOS, and highlight all the
 34174      glyphs between those two.  This may cover more than just the text
 34175      between START_CHARPOS and END_CHARPOS if the range of characters
 34176      strides the bidi level boundary, e.g. if the beginning is in R2L
 34177      text while the end is in L2R text or vice versa.  */
 34178   if (!r1->reversed_p)
 34179     {
 34180       /* This row is in a left to right paragraph.  Scan it left to
 34181          right.  */
 34182       glyph = r1->glyphs[TEXT_AREA];
 34183       end = glyph + r1->used[TEXT_AREA];
 34184       x = r1->x;
 34185 
 34186       /* Skip truncation glyphs at the start of the glyph row.  */
 34187       if (MATRIX_ROW_DISPLAYS_TEXT_P (r1))
 34188         for (; glyph < end
 34189                && NILP (glyph->object)
 34190                && glyph->charpos < 0;
 34191              ++glyph)
 34192           x += glyph->pixel_width;
 34193 
 34194       /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
 34195          or DISP_STRING, and the first glyph from buffer whose
 34196          position is between START_CHARPOS and END_CHARPOS.  */
 34197       for (; glyph < end
 34198              && !NILP (glyph->object)
 34199              && !EQ (glyph->object, disp_string)
 34200              && !(BUFFERP (glyph->object)
 34201                   && (glyph->charpos >= start_charpos
 34202                       && glyph->charpos < end_charpos));
 34203            ++glyph)
 34204         {
 34205           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34206              are present at buffer positions between START_CHARPOS and
 34207              END_CHARPOS, or if they come from an overlay.  */
 34208           if (EQ (glyph->object, before_string))
 34209             {
 34210               pos = string_buffer_position (before_string,
 34211                                             start_charpos);
 34212               /* If pos == 0, it means before_string came from an
 34213                  overlay, not from a buffer position.  */
 34214               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34215                 break;
 34216             }
 34217           else if (EQ (glyph->object, after_string))
 34218             {
 34219               pos = string_buffer_position (after_string, end_charpos);
 34220               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34221                 break;
 34222             }
 34223           x += glyph->pixel_width;
 34224         }
 34225       hlinfo->mouse_face_beg_x = x;
 34226       hlinfo->mouse_face_beg_col = glyph - r1->glyphs[TEXT_AREA];
 34227     }
 34228   else
 34229     {
 34230       /* This row is in a right to left paragraph.  Scan it right to
 34231          left.  */
 34232       struct glyph *g;
 34233 
 34234       end = r1->glyphs[TEXT_AREA] - 1;
 34235       glyph = end + r1->used[TEXT_AREA];
 34236 
 34237       /* Skip truncation glyphs at the start of the glyph row.  */
 34238       if (MATRIX_ROW_DISPLAYS_TEXT_P (r1))
 34239         for (; glyph > end
 34240                && NILP (glyph->object)
 34241                && glyph->charpos < 0;
 34242              --glyph)
 34243           ;
 34244 
 34245       /* Scan the glyph row, looking for BEFORE_STRING, AFTER_STRING,
 34246          or DISP_STRING, and the first glyph from buffer whose
 34247          position is between START_CHARPOS and END_CHARPOS.  */
 34248       for (; glyph > end
 34249              && !NILP (glyph->object)
 34250              && !EQ (glyph->object, disp_string)
 34251              && !(BUFFERP (glyph->object)
 34252                   && (glyph->charpos >= start_charpos
 34253                       && glyph->charpos < end_charpos));
 34254            --glyph)
 34255         {
 34256           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34257              are present at buffer positions between START_CHARPOS and
 34258              END_CHARPOS, or if they come from an overlay.  */
 34259           if (EQ (glyph->object, before_string))
 34260             {
 34261               pos = string_buffer_position (before_string, start_charpos);
 34262               /* If pos == 0, it means before_string came from an
 34263                  overlay, not from a buffer position.  */
 34264               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34265                 break;
 34266             }
 34267           else if (EQ (glyph->object, after_string))
 34268             {
 34269               pos = string_buffer_position (after_string, end_charpos);
 34270               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34271                 break;
 34272             }
 34273         }
 34274 
 34275       glyph++; /* first glyph to the right of the highlighted area */
 34276       for (g = r1->glyphs[TEXT_AREA], x = r1->x; g < glyph; g++)
 34277         x += g->pixel_width;
 34278       hlinfo->mouse_face_beg_x = x;
 34279       hlinfo->mouse_face_beg_col = glyph - r1->glyphs[TEXT_AREA];
 34280     }
 34281 
 34282   /* If the highlight ends in a different row, compute GLYPH and END
 34283      for the end row.  Otherwise, reuse the values computed above for
 34284      the row where the highlight begins.  */
 34285   if (r2 != r1)
 34286     {
 34287       if (!r2->reversed_p)
 34288         {
 34289           glyph = r2->glyphs[TEXT_AREA];
 34290           end = glyph + r2->used[TEXT_AREA];
 34291           x = r2->x;
 34292         }
 34293       else
 34294         {
 34295           end = r2->glyphs[TEXT_AREA] - 1;
 34296           glyph = end + r2->used[TEXT_AREA];
 34297         }
 34298     }
 34299 
 34300   if (!r2->reversed_p)
 34301     {
 34302       /* Skip truncation and continuation glyphs near the end of the
 34303          row, and also blanks and stretch glyphs inserted by
 34304          extend_face_to_end_of_line.  */
 34305       while (end > glyph
 34306              && NILP ((end - 1)->object))
 34307         --end;
 34308       /* Scan the rest of the glyph row from the end, looking for the
 34309          first glyph that comes from BEFORE_STRING, AFTER_STRING, or
 34310          DISP_STRING, or whose position is between START_CHARPOS
 34311          and END_CHARPOS */
 34312       for (--end;
 34313              end > glyph
 34314              && !NILP (end->object)
 34315              && !EQ (end->object, disp_string)
 34316              && !(BUFFERP (end->object)
 34317                   && (end->charpos >= start_charpos
 34318                       && end->charpos < end_charpos));
 34319            --end)
 34320         {
 34321           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34322              are present at buffer positions between START_CHARPOS and
 34323              END_CHARPOS, or if they come from an overlay.  */
 34324           if (EQ (end->object, before_string))
 34325             {
 34326               pos = string_buffer_position (before_string, start_charpos);
 34327               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34328                 break;
 34329             }
 34330           else if (EQ (end->object, after_string))
 34331             {
 34332               pos = string_buffer_position (after_string, end_charpos);
 34333               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34334                 break;
 34335             }
 34336         }
 34337       /* Find the X coordinate of the last glyph to be highlighted.  */
 34338       for (; glyph <= end; ++glyph)
 34339         x += glyph->pixel_width;
 34340 
 34341       hlinfo->mouse_face_end_x = x;
 34342       hlinfo->mouse_face_end_col = glyph - r2->glyphs[TEXT_AREA];
 34343     }
 34344   else
 34345     {
 34346       /* Skip truncation and continuation glyphs near the end of the
 34347          row, and also blanks and stretch glyphs inserted by
 34348          extend_face_to_end_of_line.  */
 34349       x = r2->x;
 34350       end++;
 34351       while (end < glyph
 34352              && NILP (end->object))
 34353         {
 34354           x += end->pixel_width;
 34355           ++end;
 34356         }
 34357       /* Scan the rest of the glyph row from the end, looking for the
 34358          first glyph that comes from BEFORE_STRING, AFTER_STRING, or
 34359          DISP_STRING, or whose position is between START_CHARPOS
 34360          and END_CHARPOS */
 34361       for ( ;
 34362              end < glyph
 34363              && !NILP (end->object)
 34364              && !EQ (end->object, disp_string)
 34365              && !(BUFFERP (end->object)
 34366                   && (end->charpos >= start_charpos
 34367                       && end->charpos < end_charpos));
 34368            ++end)
 34369         {
 34370           /* BEFORE_STRING or AFTER_STRING are only relevant if they
 34371              are present at buffer positions between START_CHARPOS and
 34372              END_CHARPOS, or if they come from an overlay.  */
 34373           if (EQ (end->object, before_string))
 34374             {
 34375               pos = string_buffer_position (before_string, start_charpos);
 34376               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34377                 break;
 34378             }
 34379           else if (EQ (end->object, after_string))
 34380             {
 34381               pos = string_buffer_position (after_string, end_charpos);
 34382               if (!pos || (pos >= start_charpos && pos < end_charpos))
 34383                 break;
 34384             }
 34385           x += end->pixel_width;
 34386         }
 34387       /* If we exited the above loop because we arrived at the last
 34388          glyph of the row, and its buffer position is still not in
 34389          range, it means the last character in range is the preceding
 34390          newline.  Bump the end column and x values to get past the
 34391          last glyph.  */
 34392       if (end == glyph
 34393           && BUFFERP (end->object)
 34394           && (end->charpos < start_charpos
 34395               || end->charpos >= end_charpos))
 34396         {
 34397           x += end->pixel_width;
 34398           ++end;
 34399         }
 34400       hlinfo->mouse_face_end_x = x;
 34401       hlinfo->mouse_face_end_col = end - r2->glyphs[TEXT_AREA];
 34402     }
 34403 
 34404   hlinfo->mouse_face_window = window;
 34405   hlinfo->mouse_face_face_id
 34406     = face_at_buffer_position (w, mouse_charpos, &ignore,
 34407                                mouse_charpos + 1,
 34408                                !hlinfo->mouse_face_hidden, -1, 0);
 34409   show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
 34410 }
 34411 
 34412 /* The following function is not used anymore (replaced with
 34413    mouse_face_from_string_pos), but I leave it here for the time
 34414    being, in case someone would.  */
 34415 
 34416 #if false       /* not used */
 34417 
 34418 /* Find the position of the glyph for position POS in OBJECT in
 34419    window W's current matrix, and return in *X, *Y the pixel
 34420    coordinates, and return in *HPOS, *VPOS the column/row of the glyph.
 34421 
 34422    RIGHT_P means return the position of the right edge of the glyph.
 34423    !RIGHT_P means return the left edge position.
 34424 
 34425    If no glyph for POS exists in the matrix, return the position of
 34426    the glyph with the next smaller position that is in the matrix, if
 34427    RIGHT_P is false.  If RIGHT_P, and no glyph for POS
 34428    exists in the matrix, return the position of the glyph with the
 34429    next larger position in OBJECT.
 34430 
 34431    Value is true if a glyph was found.  */
 34432 
 34433 static bool
 34434 fast_find_string_pos (struct window *w, ptrdiff_t pos, Lisp_Object object,
 34435                       int *hpos, int *vpos, int *x, int *y, bool right_p)
 34436 {
 34437   int yb = window_text_bottom_y (w);
 34438   struct glyph_row *r;
 34439   struct glyph *best_glyph = NULL;
 34440   struct glyph_row *best_row = NULL;
 34441   int best_x = 0;
 34442 
 34443   for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34444        r->enabled_p && r->y < yb;
 34445        ++r)
 34446     {
 34447       struct glyph *g = r->glyphs[TEXT_AREA];
 34448       struct glyph *e = g + r->used[TEXT_AREA];
 34449       int gx;
 34450 
 34451       for (gx = r->x; g < e; gx += g->pixel_width, ++g)
 34452         if (EQ (g->object, object))
 34453           {
 34454             if (g->charpos == pos)
 34455               {
 34456                 best_glyph = g;
 34457                 best_x = gx;
 34458                 best_row = r;
 34459                 goto found;
 34460               }
 34461             else if (best_glyph == NULL
 34462                      || ((eabs (g->charpos - pos)
 34463                          < eabs (best_glyph->charpos - pos))
 34464                          && (right_p
 34465                              ? g->charpos < pos
 34466                              : g->charpos > pos)))
 34467               {
 34468                 best_glyph = g;
 34469                 best_x = gx;
 34470                 best_row = r;
 34471               }
 34472           }
 34473     }
 34474 
 34475  found:
 34476 
 34477   if (best_glyph)
 34478     {
 34479       *x = best_x;
 34480       *hpos = best_glyph - best_row->glyphs[TEXT_AREA];
 34481 
 34482       if (right_p)
 34483         {
 34484           *x += best_glyph->pixel_width;
 34485           ++*hpos;
 34486         }
 34487 
 34488       *y = best_row->y;
 34489       *vpos = MATRIX_ROW_VPOS (best_row, w->current_matrix);
 34490     }
 34491 
 34492   return best_glyph != NULL;
 34493 }
 34494 #endif  /* not used */
 34495 
 34496 /* Find the positions of the first and the last glyphs in window W's
 34497    current matrix that occlude positions [STARTPOS..ENDPOS) in OBJECT
 34498    (assumed to be a string), and return in HLINFO's mouse_face_*
 34499    members the pixel and column/row coordinates of those glyphs.  */
 34500 
 34501 static void
 34502 mouse_face_from_string_pos (struct window *w, Mouse_HLInfo *hlinfo,
 34503                             Lisp_Object object,
 34504                             ptrdiff_t startpos, ptrdiff_t endpos)
 34505 {
 34506   int yb = window_text_bottom_y (w);
 34507   struct glyph_row *r;
 34508   struct glyph *g, *e;
 34509   int gx;
 34510   bool found = false;
 34511 
 34512   /* Find the glyph row with at least one position in the range
 34513      [STARTPOS..ENDPOS), and the first glyph in that row whose
 34514      position belongs to that range.  */
 34515   for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
 34516        r->enabled_p && r->y < yb;
 34517        ++r)
 34518     {
 34519       if (!r->reversed_p)
 34520         {
 34521           g = r->glyphs[TEXT_AREA];
 34522           e = g + r->used[TEXT_AREA];
 34523           for (gx = r->x; g < e; gx += g->pixel_width, ++g)
 34524             if (EQ (g->object, object)
 34525                 && startpos <= g->charpos && g->charpos < endpos)
 34526               {
 34527                 hlinfo->mouse_face_beg_row
 34528                   = MATRIX_ROW_VPOS (r, w->current_matrix);
 34529                 hlinfo->mouse_face_beg_col = g - r->glyphs[TEXT_AREA];
 34530                 hlinfo->mouse_face_beg_x = gx;
 34531                 found = true;
 34532                 break;
 34533               }
 34534         }
 34535       else
 34536         {
 34537           struct glyph *g1;
 34538 
 34539           e = r->glyphs[TEXT_AREA];
 34540           g = e + r->used[TEXT_AREA];
 34541           for ( ; g > e; --g)
 34542             if (EQ ((g-1)->object, object)
 34543                 && startpos <= (g-1)->charpos && (g-1)->charpos < endpos)
 34544               {
 34545                 hlinfo->mouse_face_beg_row
 34546                   = MATRIX_ROW_VPOS (r, w->current_matrix);
 34547                 hlinfo->mouse_face_beg_col = g - r->glyphs[TEXT_AREA];
 34548                 for (gx = r->x, g1 = r->glyphs[TEXT_AREA]; g1 < g; ++g1)
 34549                   gx += g1->pixel_width;
 34550                 hlinfo->mouse_face_beg_x = gx;
 34551                 found = true;
 34552                 break;
 34553               }
 34554         }
 34555       if (found)
 34556         break;
 34557     }
 34558 
 34559   if (!found)
 34560     return;
 34561 
 34562   /* Starting with the next row, look for the first row which does NOT
 34563      include any glyphs whose positions are in the range.  */
 34564   for (++r; r->enabled_p && r->y < yb; ++r)
 34565     {
 34566       g = r->glyphs[TEXT_AREA];
 34567       e = g + r->used[TEXT_AREA];
 34568       found = false;
 34569       for ( ; g < e; ++g)
 34570         if (EQ (g->object, object)
 34571             && startpos <= g->charpos && g->charpos < endpos)
 34572           {
 34573             found = true;
 34574             break;
 34575           }
 34576       if (!found)
 34577         break;
 34578     }
 34579 
 34580   /* The highlighted region ends on the previous row.  */
 34581   r--;
 34582 
 34583   /* Set the end row.  */
 34584   hlinfo->mouse_face_end_row = MATRIX_ROW_VPOS (r, w->current_matrix);
 34585 
 34586   /* Compute and set the end column and the end column's horizontal
 34587      pixel coordinate.  */
 34588   if (!r->reversed_p)
 34589     {
 34590       g = r->glyphs[TEXT_AREA];
 34591       e = g + r->used[TEXT_AREA];
 34592       for ( ; e > g; --e)
 34593         if (EQ ((e-1)->object, object)
 34594             && startpos <= (e-1)->charpos && (e-1)->charpos < endpos)
 34595           break;
 34596       hlinfo->mouse_face_end_col = e - g;
 34597 
 34598       for (gx = r->x; g < e; ++g)
 34599         gx += g->pixel_width;
 34600       hlinfo->mouse_face_end_x = gx;
 34601     }
 34602   else
 34603     {
 34604       e = r->glyphs[TEXT_AREA];
 34605       g = e + r->used[TEXT_AREA];
 34606       for (gx = r->x ; e < g; ++e)
 34607         {
 34608           if (EQ (e->object, object)
 34609               && startpos <= e->charpos && e->charpos < endpos)
 34610             break;
 34611           gx += e->pixel_width;
 34612         }
 34613       hlinfo->mouse_face_end_col = e - r->glyphs[TEXT_AREA];
 34614       hlinfo->mouse_face_end_x = gx;
 34615     }
 34616 }
 34617 
 34618 #ifdef HAVE_WINDOW_SYSTEM
 34619 
 34620 /* See if position X, Y is within a hot-spot of an image.  */
 34621 
 34622 static bool
 34623 on_hot_spot_p (Lisp_Object hot_spot, int x, int y)
 34624 {
 34625   if (!CONSP (hot_spot))
 34626     return false;
 34627 
 34628   if (EQ (XCAR (hot_spot), Qrect))
 34629     {
 34630       /* CDR is (Top-Left . Bottom-Right) = ((x0 . y0) . (x1 . y1))  */
 34631       Lisp_Object rect = XCDR (hot_spot);
 34632       Lisp_Object tem;
 34633       if (!CONSP (rect))
 34634         return false;
 34635       if (!CONSP (XCAR (rect)))
 34636         return false;
 34637       if (!CONSP (XCDR (rect)))
 34638         return false;
 34639       if (!(tem = XCAR (XCAR (rect)), FIXNUMP (tem) && x >= XFIXNUM (tem)))
 34640         return false;
 34641       if (!(tem = XCDR (XCAR (rect)), FIXNUMP (tem) && y >= XFIXNUM (tem)))
 34642         return false;
 34643       if (!(tem = XCAR (XCDR (rect)), FIXNUMP (tem) && x <= XFIXNUM (tem)))
 34644         return false;
 34645       if (!(tem = XCDR (XCDR (rect)), FIXNUMP (tem) && y <= XFIXNUM (tem)))
 34646         return false;
 34647       return true;
 34648     }
 34649   else if (EQ (XCAR (hot_spot), Qcircle))
 34650     {
 34651       /* CDR is (Center . Radius) = ((x0 . y0) . r) */
 34652       Lisp_Object circ = XCDR (hot_spot);
 34653       Lisp_Object lr, lx0, ly0;
 34654       if (CONSP (circ)
 34655           && CONSP (XCAR (circ))
 34656           && (lr = XCDR (circ), NUMBERP (lr))
 34657           && (lx0 = XCAR (XCAR (circ)), FIXNUMP (lx0))
 34658           && (ly0 = XCDR (XCAR (circ)), FIXNUMP (ly0)))
 34659         {
 34660           double r = XFLOATINT (lr);
 34661           double dx = XFIXNUM (lx0) - x;
 34662           double dy = XFIXNUM (ly0) - y;
 34663           return (dx * dx + dy * dy <= r * r);
 34664         }
 34665     }
 34666   else if (EQ (XCAR (hot_spot), Qpoly))
 34667     {
 34668       /* CDR is [x0 y0 x1 y1 x2 y2 ...x(n-1) y(n-1)] */
 34669       if (VECTORP (XCDR (hot_spot)))
 34670         {
 34671           struct Lisp_Vector *v = XVECTOR (XCDR (hot_spot));
 34672           Lisp_Object *poly = v->contents;
 34673           ptrdiff_t n = v->header.size;
 34674           ptrdiff_t i;
 34675           bool inside = false;
 34676           Lisp_Object lx, ly;
 34677           int x0, y0;
 34678 
 34679           /* Need an even number of coordinates, and at least 3 edges.  */
 34680           if (n < 6 || n & 1)
 34681             return false;
 34682 
 34683           /* Count edge segments intersecting line from (X,Y) to (X,infinity).
 34684              If count is odd, we are inside polygon.  Pixels on edges
 34685              may or may not be included depending on actual geometry of the
 34686              polygon.  */
 34687           if ((lx = poly[n-2], !FIXNUMP (lx))
 34688               || (ly = poly[n-1], !FIXNUMP (lx)))
 34689             return false;
 34690           x0 = XFIXNUM (lx), y0 = XFIXNUM (ly);
 34691           for (i = 0; i < n; i += 2)
 34692             {
 34693               int x1 = x0, y1 = y0;
 34694               if ((lx = poly[i], !FIXNUMP (lx))
 34695                   || (ly = poly[i+1], !FIXNUMP (ly)))
 34696                 return false;
 34697               x0 = XFIXNUM (lx), y0 = XFIXNUM (ly);
 34698 
 34699               /* Does this segment cross the X line?  */
 34700               if (x0 >= x)
 34701                 {
 34702                   if (x1 >= x)
 34703                     continue;
 34704                 }
 34705               else if (x1 < x)
 34706                 continue;
 34707               if (y > y0 && y > y1)
 34708                 continue;
 34709               if (y < y0 + ((y1 - y0) * (x - x0)) / (x1 - x0))
 34710                 inside = !inside;
 34711             }
 34712           return inside;
 34713         }
 34714     }
 34715   return false;
 34716 }
 34717 
 34718 Lisp_Object
 34719 find_hot_spot (Lisp_Object map, int x, int y)
 34720 {
 34721   while (CONSP (map))
 34722     {
 34723       if (CONSP (XCAR (map))
 34724           && on_hot_spot_p (XCAR (XCAR (map)), x, y))
 34725         return XCAR (map);
 34726       map = XCDR (map);
 34727     }
 34728 
 34729   return Qnil;
 34730 }
 34731 
 34732 DEFUN ("lookup-image-map", Flookup_image_map, Slookup_image_map,
 34733        3, 3, 0,
 34734        doc: /* Lookup in image map MAP coordinates X and Y.
 34735 An image map is an alist where each element has the format (AREA ID PLIST).
 34736 An AREA is specified as either a rectangle, a circle, or a polygon:
 34737 A rectangle is a cons (rect . ((x0 . y0) . (x1 . y1))) specifying the
 34738 pixel coordinates of the upper left and bottom right corners.
 34739 A circle is a cons (circle . ((x0 . y0) . r)) specifying the center
 34740 and the radius of the circle; r may be a float or integer.
 34741 A polygon is a cons (poly . [x0 y0 x1 y1 ...]) where each pair in the
 34742 vector describes one corner in the polygon.
 34743 Returns the alist element for the first matching AREA in MAP.  */)
 34744   (Lisp_Object map, Lisp_Object x, Lisp_Object y)
 34745 {
 34746   if (NILP (map))
 34747     return Qnil;
 34748 
 34749   CHECK_FIXNUM (x);
 34750   CHECK_FIXNUM (y);
 34751 
 34752   return find_hot_spot (map,
 34753                         clip_to_bounds (INT_MIN, XFIXNUM (x), INT_MAX),
 34754                         clip_to_bounds (INT_MIN, XFIXNUM (y), INT_MAX));
 34755 }
 34756 #endif  /* HAVE_WINDOW_SYSTEM */
 34757 
 34758 
 34759 /* Display frame CURSOR, optionally using shape defined by POINTER.  */
 34760 static void
 34761 define_frame_cursor1 (struct frame *f, Emacs_Cursor cursor, Lisp_Object pointer)
 34762 {
 34763 #ifdef HAVE_WINDOW_SYSTEM
 34764   if (!FRAME_WINDOW_P (f))
 34765     return;
 34766 
 34767   /* Do not change cursor shape while dragging mouse.  */
 34768   if (EQ (track_mouse, Qdragging) || EQ (track_mouse, Qdropping)
 34769       || EQ (track_mouse, Qdrag_source))
 34770     return;
 34771 
 34772   if (!NILP (pointer))
 34773     {
 34774       if (EQ (pointer, Qarrow))
 34775         cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 34776       else if (EQ (pointer, Qhand))
 34777         cursor = FRAME_OUTPUT_DATA (f)->hand_cursor;
 34778       else if (EQ (pointer, Qtext))
 34779         cursor = FRAME_OUTPUT_DATA (f)->text_cursor;
 34780       else if (EQ (pointer, intern ("hdrag")))
 34781         cursor = FRAME_OUTPUT_DATA (f)->horizontal_drag_cursor;
 34782       else if (EQ (pointer, intern ("nhdrag")))
 34783         cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 34784 # ifdef HAVE_X_WINDOWS
 34785       else if (EQ (pointer, intern ("vdrag")))
 34786         cursor = FRAME_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
 34787 # endif
 34788       else if (EQ (pointer, intern ("hourglass")))
 34789         cursor = FRAME_OUTPUT_DATA (f)->hourglass_cursor;
 34790       else if (EQ (pointer, Qmodeline))
 34791         cursor = FRAME_OUTPUT_DATA (f)->modeline_cursor;
 34792       else
 34793         cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 34794     }
 34795 
 34796   if (cursor != No_Cursor)
 34797     FRAME_RIF (f)->define_frame_cursor (f, cursor);
 34798 #endif
 34799 }
 34800 
 34801 /* Take proper action when mouse has moved to the mode or header line
 34802    or marginal area AREA of window W, x-position X and y-position Y.
 34803    X is relative to the start of the text display area of W, so the
 34804    width of bitmap areas and scroll bars must be subtracted to get a
 34805    position relative to the start of the mode line.  */
 34806 
 34807 static void
 34808 note_mode_line_or_margin_highlight (Lisp_Object window, int x, int y,
 34809                                     enum window_part area)
 34810 {
 34811   struct window *w = XWINDOW (window);
 34812   struct frame *f = XFRAME (w->frame);
 34813   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 34814   Emacs_Cursor cursor = No_Cursor;
 34815   Lisp_Object pointer = Qnil;
 34816   int dx, dy, width, height;
 34817   ptrdiff_t charpos;
 34818   Lisp_Object string, object = Qnil;
 34819   Lisp_Object pos UNINIT;
 34820   Lisp_Object mouse_face;
 34821   int original_x_pixel = x;
 34822   struct glyph * glyph = NULL, * row_start_glyph = NULL;
 34823   struct glyph_row *row UNINIT;
 34824 
 34825   if (area == ON_MODE_LINE || area == ON_HEADER_LINE || area == ON_TAB_LINE)
 34826     {
 34827       int x0;
 34828       struct glyph *end;
 34829 
 34830       /* Kludge alert: mode_line_string takes X/Y in pixels, but
 34831          returns them in row/column units!  */
 34832       string = mode_line_string (w, area, &x, &y, &charpos,
 34833                                  &object, &dx, &dy, &width, &height);
 34834 
 34835       row = (area == ON_MODE_LINE
 34836              ? MATRIX_MODE_LINE_ROW (w->current_matrix)
 34837              : (area == ON_TAB_LINE
 34838                 ? MATRIX_TAB_LINE_ROW (w->current_matrix)
 34839                 : MATRIX_HEADER_LINE_ROW (w->current_matrix)));
 34840 
 34841       /* Find the glyph under the mouse pointer.  */
 34842       if (row->mode_line_p && row->enabled_p)
 34843         {
 34844           glyph = row_start_glyph = row->glyphs[TEXT_AREA];
 34845           end = glyph + row->used[TEXT_AREA];
 34846 
 34847           for (x0 = original_x_pixel;
 34848                glyph < end && x0 >= glyph->pixel_width;
 34849                ++glyph)
 34850             x0 -= glyph->pixel_width;
 34851 
 34852           if (glyph >= end)
 34853             glyph = NULL;
 34854         }
 34855     }
 34856   else
 34857     {
 34858       x -= WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w);
 34859       /* Kludge alert: marginal_area_string takes X/Y in pixels, but
 34860          returns them in row/column units!  */
 34861       string = marginal_area_string (w, area, &x, &y, &charpos,
 34862                                      &object, &dx, &dy, &width, &height);
 34863     }
 34864 
 34865   Lisp_Object help = Qnil;
 34866 
 34867 #ifdef HAVE_WINDOW_SYSTEM
 34868   if (IMAGEP (object))
 34869     {
 34870       Lisp_Object image_map, hotspot;
 34871       if ((image_map = plist_get (XCDR (object), QCmap),
 34872            !NILP (image_map))
 34873           && (hotspot = find_hot_spot (image_map, dx, dy),
 34874               CONSP (hotspot))
 34875           && (hotspot = XCDR (hotspot), CONSP (hotspot)))
 34876         {
 34877           Lisp_Object plist;
 34878 
 34879           /* Could check XCAR (hotspot) to see if we enter/leave this hot-spot.
 34880              If so, we could look for mouse-enter, mouse-leave
 34881              properties in PLIST (and do something...).  */
 34882           hotspot = XCDR (hotspot);
 34883           if (CONSP (hotspot)
 34884               && (plist = XCAR (hotspot), CONSP (plist)))
 34885             {
 34886               pointer = plist_get (plist, Qpointer);
 34887               if (NILP (pointer))
 34888                 pointer = Qhand;
 34889               help = plist_get (plist, Qhelp_echo);
 34890               if (!NILP (help))
 34891                 {
 34892                   help_echo_string = help;
 34893                   XSETWINDOW (help_echo_window, w);
 34894                   help_echo_object = w->contents;
 34895                   help_echo_pos = charpos;
 34896                 }
 34897             }
 34898         }
 34899       if (NILP (pointer))
 34900         pointer = plist_get (XCDR (object), QCpointer);
 34901     }
 34902 #endif  /* HAVE_WINDOW_SYSTEM */
 34903 
 34904   /* CHARPOS can be beyond the last position of STRING due, e.g., to
 34905      min-width 'display' property.  Fix that, to let all the calls to
 34906      get-text-property below do their thing.  */
 34907   if (STRINGP (string))
 34908     pos = make_fixnum (min (charpos, SCHARS (string) - 1));
 34909 
 34910   /* Set the help text and mouse pointer.  If the mouse is on a part
 34911      of the mode line without any text (e.g. past the right edge of
 34912      the mode line text), use that windows's mode line help echo if it
 34913      has been set.  */
 34914   if (STRINGP (string) || area == ON_MODE_LINE || area == ON_HEADER_LINE
 34915       || area == ON_TAB_LINE)
 34916     {
 34917       /* Arrange to display the help by setting the global variables
 34918          help_echo_string, help_echo_object, and help_echo_pos.  */
 34919       if (NILP (help))
 34920         {
 34921           if (STRINGP (string))
 34922             help = Fget_text_property (pos, Qhelp_echo, string);
 34923 
 34924           if (!NILP (help))
 34925             {
 34926               help_echo_string = help;
 34927               XSETWINDOW (help_echo_window, w);
 34928               help_echo_object = string;
 34929               help_echo_pos = charpos;
 34930             }
 34931           else if (area == ON_MODE_LINE
 34932                    && !NILP (w->mode_line_help_echo))
 34933             {
 34934               help_echo_string =  w->mode_line_help_echo;
 34935               XSETWINDOW (help_echo_window, w);
 34936               help_echo_object = Qnil;
 34937               help_echo_pos = -1;
 34938             }
 34939         }
 34940 
 34941 #ifdef HAVE_WINDOW_SYSTEM
 34942       /* Change the mouse pointer according to what is under it.  */
 34943       if (FRAME_WINDOW_P (f))
 34944         {
 34945           bool draggable = (! WINDOW_BOTTOMMOST_P (w)
 34946                             || minibuf_level
 34947                             || NILP (Vresize_mini_windows));
 34948 
 34949           if (STRINGP (string))
 34950             {
 34951               cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 34952 
 34953               if (NILP (pointer))
 34954                 pointer = Fget_text_property (pos, Qpointer, string);
 34955 
 34956               /* Change the mouse pointer according to what is under X/Y.  */
 34957               if (NILP (pointer)
 34958                   && (area == ON_MODE_LINE || area == ON_HEADER_LINE
 34959                       || area == ON_TAB_LINE))
 34960                 {
 34961                   Lisp_Object map;
 34962 
 34963                   map = Fget_text_property (pos, Qlocal_map, string);
 34964                   if (!KEYMAPP (map))
 34965                     map = Fget_text_property (pos, Qkeymap, string);
 34966                   if (!KEYMAPP (map) && draggable && area == ON_MODE_LINE)
 34967                     cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 34968                 }
 34969             }
 34970           else if (draggable && area == ON_MODE_LINE)
 34971             cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 34972           else if ((area == ON_MODE_LINE
 34973                     && WINDOW_BOTTOMMOST_P (w)
 34974                     && !FRAME_HAS_MINIBUF_P (f)
 34975                     && !NILP (Fframe_parameter
 34976                               (w->frame, Qdrag_with_mode_line)))
 34977                    || (((area == ON_HEADER_LINE
 34978                          && !NILP (Fframe_parameter
 34979                                    (w->frame, Qdrag_with_header_line)))
 34980                         || (area == ON_TAB_LINE
 34981                             && !NILP (Fframe_parameter
 34982                                       (w->frame, Qdrag_with_tab_line))))
 34983                        && WINDOW_TOPMOST_P (w)))
 34984             cursor = FRAME_OUTPUT_DATA (f)->hand_cursor;
 34985           else
 34986             cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 34987         }
 34988 #endif
 34989     }
 34990 
 34991   /* Change the mouse face according to what is under X/Y.  */
 34992   bool mouse_face_shown = false;
 34993 
 34994   if (STRINGP (string))
 34995     {
 34996       mouse_face = Fget_text_property (pos, Qmouse_face, string);
 34997       if (!NILP (Vmouse_highlight) && !NILP (mouse_face)
 34998           && ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE)
 34999               || (area == ON_TAB_LINE))
 35000           && glyph)
 35001         {
 35002           Lisp_Object b, e;
 35003 
 35004           struct glyph * tmp_glyph;
 35005 
 35006           int gpos;
 35007           int gseq_length;
 35008           int total_pixel_width;
 35009           ptrdiff_t begpos, endpos, ignore;
 35010 
 35011           int vpos, hpos;
 35012 
 35013           b = Fprevious_single_property_change (make_fixnum (charpos + 1),
 35014                                                 Qmouse_face, string, Qnil);
 35015           if (NILP (b))
 35016             begpos = 0;
 35017           else
 35018             begpos = XFIXNUM (b);
 35019 
 35020           e = Fnext_single_property_change (pos, Qmouse_face, string, Qnil);
 35021           if (NILP (e))
 35022             endpos = SCHARS (string);
 35023           else
 35024             endpos = XFIXNUM (e);
 35025 
 35026           /* Calculate the glyph position GPOS of GLYPH in the
 35027              displayed string, relative to the beginning of the
 35028              highlighted part of the string.
 35029 
 35030              Note: GPOS is different from CHARPOS.  CHARPOS is the
 35031              position of GLYPH in the internal string object.  A mode
 35032              line string format has structures which are converted to
 35033              a flattened string by the Emacs Lisp interpreter.  The
 35034              internal string is an element of those structures.  The
 35035              displayed string is the flattened string.  */
 35036           tmp_glyph = row_start_glyph;
 35037           while (tmp_glyph < glyph
 35038                  && (!(EQ (tmp_glyph->object, glyph->object)
 35039                        && begpos <= tmp_glyph->charpos
 35040                        && tmp_glyph->charpos < endpos)))
 35041             tmp_glyph++;
 35042           gpos = glyph - tmp_glyph;
 35043 
 35044           /* Calculate the length GSEQ_LENGTH of the glyph sequence of
 35045              the highlighted part of the displayed string to which
 35046              GLYPH belongs.  Note: GSEQ_LENGTH is different from
 35047              SCHARS (STRING), because the latter returns the length of
 35048              the internal string.  */
 35049           for (tmp_glyph = row->glyphs[TEXT_AREA] + row->used[TEXT_AREA] - 1;
 35050                tmp_glyph > glyph
 35051                  && (!(EQ (tmp_glyph->object, glyph->object)
 35052                        && begpos <= tmp_glyph->charpos
 35053                        && tmp_glyph->charpos < endpos));
 35054                tmp_glyph--)
 35055             ;
 35056           gseq_length = gpos + (tmp_glyph - glyph) + 1;
 35057 
 35058           /* Calculate the total pixel width of all the glyphs between
 35059              the beginning of the highlighted area and GLYPH.  */
 35060           total_pixel_width = 0;
 35061           for (tmp_glyph = glyph - gpos; tmp_glyph != glyph; tmp_glyph++)
 35062             total_pixel_width += tmp_glyph->pixel_width;
 35063 
 35064           /* Pre calculation of re-rendering position.  Note: X is in
 35065              column units here, after the call to mode_line_string or
 35066              marginal_area_string.  */
 35067           hpos = x - gpos;
 35068           vpos = (area == ON_MODE_LINE
 35069                   ? (w->current_matrix)->nrows - 1
 35070                   : (area == ON_TAB_LINE
 35071                      ? 0
 35072                      : (w->current_matrix->tab_line_p
 35073                         ? 1
 35074                         : 0)));
 35075 
 35076           /* If GLYPH's position is included in the region that is
 35077              already drawn in mouse face, we have nothing to do.  */
 35078           if ( EQ (window, hlinfo->mouse_face_window)
 35079                && (!row->reversed_p
 35080                    ? (hlinfo->mouse_face_beg_col <= hpos
 35081                       && hpos < hlinfo->mouse_face_end_col)
 35082                    /* In R2L rows we swap BEG and END, see below.  */
 35083                    : (hlinfo->mouse_face_end_col <= hpos
 35084                       && hpos < hlinfo->mouse_face_beg_col))
 35085                && hlinfo->mouse_face_beg_row == vpos )
 35086             return;
 35087 
 35088           if (clear_mouse_face (hlinfo))
 35089             cursor = No_Cursor;
 35090 
 35091           if (!row->reversed_p)
 35092             {
 35093               hlinfo->mouse_face_beg_col = hpos;
 35094               hlinfo->mouse_face_beg_x   = original_x_pixel
 35095                                             - (total_pixel_width + dx);
 35096               hlinfo->mouse_face_end_col = hpos + gseq_length;
 35097               hlinfo->mouse_face_end_x   = 0;
 35098             }
 35099           else
 35100             {
 35101               /* In R2L rows, show_mouse_face expects BEG and END
 35102                  coordinates to be swapped.  */
 35103               hlinfo->mouse_face_end_col = hpos;
 35104               hlinfo->mouse_face_end_x   = original_x_pixel
 35105                                             - (total_pixel_width + dx);
 35106               hlinfo->mouse_face_beg_col = hpos + gseq_length;
 35107               hlinfo->mouse_face_beg_x   = 0;
 35108             }
 35109 
 35110           hlinfo->mouse_face_beg_row  = vpos;
 35111           hlinfo->mouse_face_end_row  = hlinfo->mouse_face_beg_row;
 35112           hlinfo->mouse_face_past_end = false;
 35113           hlinfo->mouse_face_window   = window;
 35114 
 35115           hlinfo->mouse_face_face_id =
 35116             face_at_string_position (w, string, charpos, 0, &ignore,
 35117                                      glyph->face_id, true, 0);
 35118 
 35119           show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
 35120           mouse_face_shown = true;
 35121 
 35122           if (NILP (pointer))
 35123             pointer = Qhand;
 35124         }
 35125     }
 35126 
 35127   /* If mouse-face doesn't need to be shown, clear any existing
 35128      mouse-face.  */
 35129   if ((area == ON_MODE_LINE || area == ON_HEADER_LINE
 35130        || area == ON_TAB_LINE) && !mouse_face_shown)
 35131     clear_mouse_face (hlinfo);
 35132 
 35133   define_frame_cursor1 (f, cursor, pointer);
 35134 }
 35135 
 35136 
 35137 /* EXPORT:
 35138    Take proper action when the mouse has moved to position X, Y on
 35139    frame F with regards to highlighting portions of display that have
 35140    mouse-face properties.  Also de-highlight portions of display where
 35141    the mouse was before, set the mouse pointer shape as appropriate
 35142    for the mouse coordinates, and activate help echo (tooltips).
 35143    X and Y can be negative or out of range.  */
 35144 
 35145 void
 35146 note_mouse_highlight (struct frame *f, int x, int y)
 35147 {
 35148   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 35149   enum window_part part = ON_NOTHING;
 35150   Lisp_Object window;
 35151   struct window *w;
 35152   Emacs_Cursor cursor = No_Cursor;
 35153   Lisp_Object pointer = Qnil;  /* Takes precedence over cursor!  */
 35154   struct buffer *b;
 35155 
 35156   /* When a menu is active, don't highlight because this looks odd.  */
 35157 #if defined (HAVE_X_WINDOWS) || defined (HAVE_NS) || defined (MSDOS)
 35158   if (popup_activated ())
 35159     return;
 35160 #endif
 35161 
 35162 #if defined (HAVE_HAIKU)
 35163   if (popup_activated_p)
 35164     return;
 35165 #endif
 35166 
 35167   if (!f->glyphs_initialized_p
 35168       || f->pointer_invisible)
 35169     return;
 35170 
 35171   hlinfo->mouse_face_mouse_x = x;
 35172   hlinfo->mouse_face_mouse_y = y;
 35173   hlinfo->mouse_face_mouse_frame = f;
 35174 
 35175   if (hlinfo->mouse_face_defer)
 35176     return;
 35177 
 35178   /* Which window is that in?  */
 35179   window = window_from_coordinates (f, x, y, &part, true, true);
 35180 
 35181   /* If displaying active text in another window, clear that.  */
 35182   if (! EQ (window, hlinfo->mouse_face_window)
 35183       /* Also clear if we move out of text area in same window.  */
 35184       || (!NILP (hlinfo->mouse_face_window)
 35185           && !NILP (window)
 35186           && part != ON_TEXT
 35187           && part != ON_MODE_LINE
 35188           && part != ON_HEADER_LINE
 35189           && part != ON_TAB_LINE))
 35190     clear_mouse_face (hlinfo);
 35191 
 35192   /* Reset help_echo_string.  It will get recomputed below.  */
 35193   help_echo_string = Qnil;
 35194 
 35195   /* Handle tab-bar highlight on mouse-capable TTY frames.  */
 35196   if (!FRAME_WINDOW_P (f)
 35197       && (y >= FRAME_MENU_BAR_LINES (f)
 35198           && y < FRAME_MENU_BAR_LINES (f) + FRAME_TAB_BAR_LINES (f)))
 35199     {
 35200       int prop_idx;
 35201       bool ignore;
 35202       Lisp_Object caption = tty_get_tab_bar_item (f, x, &prop_idx, &ignore);
 35203 
 35204       if (!NILP (caption))
 35205         {
 35206           help_echo_object = help_echo_window = Qnil;
 35207           help_echo_pos = -1;
 35208           help_echo_string = AREF (f->tab_bar_items,
 35209                                    prop_idx * TAB_BAR_ITEM_NSLOTS
 35210                                    + TAB_BAR_ITEM_HELP);
 35211           if (NILP (help_echo_string))
 35212             help_echo_string = caption;
 35213         }
 35214     }
 35215 
 35216 #ifdef HAVE_WINDOW_SYSTEM
 35217   /* If the cursor is on the internal border of FRAME and FRAME's
 35218      internal border is draggable, provide some visual feedback.  */
 35219   if (FRAME_INTERNAL_BORDER_WIDTH (f) > 0
 35220       && !NILP (get_frame_param (f, Qdrag_internal_border)))
 35221     {
 35222       enum internal_border_part part = frame_internal_border_part (f, x, y);
 35223 
 35224       switch (part)
 35225         {
 35226         case INTERNAL_BORDER_NONE:
 35227           if (cursor != FRAME_OUTPUT_DATA (f)->nontext_cursor)
 35228             /* Reset cursor.  */
 35229             cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35230           break;
 35231         case INTERNAL_BORDER_LEFT_EDGE:
 35232           cursor = FRAME_OUTPUT_DATA (f)->left_edge_cursor;
 35233           break;
 35234         case INTERNAL_BORDER_TOP_LEFT_CORNER:
 35235           cursor = FRAME_OUTPUT_DATA (f)->top_left_corner_cursor;
 35236           break;
 35237         case INTERNAL_BORDER_TOP_EDGE:
 35238           cursor = FRAME_OUTPUT_DATA (f)->top_edge_cursor;
 35239           break;
 35240         case INTERNAL_BORDER_TOP_RIGHT_CORNER:
 35241           cursor = FRAME_OUTPUT_DATA (f)->top_right_corner_cursor;
 35242           break;
 35243         case INTERNAL_BORDER_RIGHT_EDGE:
 35244           cursor = FRAME_OUTPUT_DATA (f)->right_edge_cursor;
 35245           break;
 35246         case INTERNAL_BORDER_BOTTOM_RIGHT_CORNER:
 35247           cursor = FRAME_OUTPUT_DATA (f)->bottom_right_corner_cursor;
 35248           break;
 35249         case INTERNAL_BORDER_BOTTOM_EDGE:
 35250           cursor = FRAME_OUTPUT_DATA (f)->bottom_edge_cursor;
 35251           break;
 35252         case INTERNAL_BORDER_BOTTOM_LEFT_CORNER:
 35253           cursor = FRAME_OUTPUT_DATA (f)->bottom_left_corner_cursor;
 35254           break;
 35255         default:
 35256           /* This should not happen.  */
 35257           if (cursor != FRAME_OUTPUT_DATA (f)->nontext_cursor)
 35258             cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35259         }
 35260 
 35261       if (cursor != FRAME_OUTPUT_DATA (f)->nontext_cursor)
 35262         {
 35263           /* Do we really want a help echo here?  */
 35264           help_echo_string = build_string ("drag-mouse-1: resize frame");
 35265           goto set_cursor;
 35266         }
 35267     }
 35268 #endif /* HAVE_WINDOW_SYSTEM */
 35269 
 35270   /* Not on a window -> return.  */
 35271   if (!WINDOWP (window))
 35272     return;
 35273 
 35274   /* Convert to window-relative pixel coordinates.  */
 35275   w = XWINDOW (window);
 35276   frame_to_window_pixel_xy (w, &x, &y);
 35277 
 35278 #if defined (HAVE_WINDOW_SYSTEM)
 35279   /* Handle tab-bar window differently since it doesn't display a
 35280      buffer.  */
 35281   if (EQ (window, f->tab_bar_window))
 35282     {
 35283       note_tab_bar_highlight (f, x, y);
 35284       if (tab_bar__dragging_in_progress)
 35285         {
 35286           cursor = FRAME_OUTPUT_DATA (f)->hand_cursor;
 35287           goto set_cursor;
 35288         }
 35289       else
 35290         return;
 35291     }
 35292   else
 35293     {
 35294       /* The mouse might have pressed into the tab bar, but might
 35295          also have been released outside the tab bar, so
 35296          f->last_tab_bar_item must be reset, in order to make sure the
 35297          item can be still highlighted again in the future.  */
 35298       f->last_tab_bar_item = -1;
 35299     }
 35300 #endif
 35301 
 35302 #if defined (HAVE_WINDOW_SYSTEM) && ! defined (HAVE_EXT_TOOL_BAR)
 35303   /* Handle tool-bar window differently since it doesn't display a
 35304      buffer.  */
 35305   if (EQ (window, f->tool_bar_window))
 35306     {
 35307       note_tool_bar_highlight (f, x, y);
 35308       return;
 35309     }
 35310 #endif
 35311 
 35312   /* Mouse is on the mode, header line or margin?  */
 35313   if (part == ON_MODE_LINE || part == ON_HEADER_LINE || part == ON_TAB_LINE
 35314       || part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
 35315     {
 35316       note_mode_line_or_margin_highlight (window, x, y, part);
 35317 
 35318 #ifdef HAVE_WINDOW_SYSTEM
 35319       if (part == ON_LEFT_MARGIN || part == ON_RIGHT_MARGIN)
 35320         {
 35321           cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35322           /* Show non-text cursor (Bug#16647).  */
 35323           goto set_cursor;
 35324         }
 35325       else
 35326 #endif
 35327         return;
 35328     }
 35329 
 35330 #ifdef HAVE_WINDOW_SYSTEM
 35331   if (part == ON_VERTICAL_BORDER)
 35332     {
 35333       cursor = FRAME_OUTPUT_DATA (f)->horizontal_drag_cursor;
 35334       help_echo_string = build_string ("drag-mouse-1: resize");
 35335       goto set_cursor;
 35336     }
 35337   else if (part == ON_RIGHT_DIVIDER)
 35338     {
 35339       cursor = FRAME_OUTPUT_DATA (f)->horizontal_drag_cursor;
 35340       help_echo_string = build_string ("drag-mouse-1: resize");
 35341       goto set_cursor;
 35342     }
 35343   else if (part == ON_BOTTOM_DIVIDER)
 35344     if (! WINDOW_BOTTOMMOST_P (w)
 35345         || minibuf_level
 35346         || NILP (Vresize_mini_windows))
 35347       {
 35348         cursor = FRAME_OUTPUT_DATA (f)->vertical_drag_cursor;
 35349         help_echo_string = build_string ("drag-mouse-1: resize");
 35350         goto set_cursor;
 35351       }
 35352     else
 35353       cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35354   else if (part == ON_LEFT_FRINGE || part == ON_RIGHT_FRINGE
 35355            || part == ON_VERTICAL_SCROLL_BAR
 35356            || part == ON_HORIZONTAL_SCROLL_BAR)
 35357     cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35358   else
 35359     cursor = FRAME_OUTPUT_DATA (f)->text_cursor;
 35360 #endif
 35361 
 35362   /* Are we in a window whose display is up to date?
 35363      And verify the buffer's text has not changed.  */
 35364   b = XBUFFER (w->contents);
 35365   if (part == ON_TEXT && w->window_end_valid && !window_outdated (w))
 35366     {
 35367       int hpos, vpos, dx, dy, area = LAST_AREA;
 35368       ptrdiff_t pos;
 35369       struct glyph *glyph;
 35370       Lisp_Object object;
 35371       Lisp_Object mouse_face = Qnil, position;
 35372       Lisp_Object *overlay_vec = NULL;
 35373       ptrdiff_t i, noverlays;
 35374       struct buffer *obuf;
 35375       ptrdiff_t obegv, ozv;
 35376       bool same_region;
 35377 
 35378       /* Find the glyph under X/Y.  */
 35379       glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &dx, &dy, &area);
 35380 
 35381 #ifdef HAVE_WINDOW_SYSTEM
 35382       /* Look for :pointer property on image.  */
 35383       if (glyph != NULL && glyph->type == IMAGE_GLYPH)
 35384         {
 35385           struct image *img = IMAGE_OPT_FROM_ID (f, glyph->u.img_id);
 35386           if (img != NULL && IMAGEP (img->spec))
 35387             {
 35388               Lisp_Object image_map, hotspot;
 35389               if ((image_map = plist_get (XCDR (img->spec), QCmap),
 35390                    !NILP (image_map))
 35391                   && (hotspot = find_hot_spot (image_map,
 35392                                                glyph->slice.img.x + dx,
 35393                                                glyph->slice.img.y + dy),
 35394                       CONSP (hotspot))
 35395                   && (hotspot = XCDR (hotspot), CONSP (hotspot)))
 35396                 {
 35397                   Lisp_Object plist;
 35398 
 35399                   /* Could check XCAR (hotspot) to see if we enter/leave
 35400                      this hot-spot.
 35401                      If so, we could look for mouse-enter, mouse-leave
 35402                      properties in PLIST (and do something...).  */
 35403                   hotspot = XCDR (hotspot);
 35404                   if (CONSP (hotspot)
 35405                       && (plist = XCAR (hotspot), CONSP (plist)))
 35406                     {
 35407                       pointer = plist_get (plist, Qpointer);
 35408                       if (NILP (pointer))
 35409                         pointer = Qhand;
 35410                       help_echo_string = plist_get (plist, Qhelp_echo);
 35411                       if (!NILP (help_echo_string))
 35412                         {
 35413                           help_echo_window = window;
 35414                           help_echo_object = glyph->object;
 35415                           help_echo_pos = glyph->charpos;
 35416                         }
 35417                     }
 35418                 }
 35419               if (NILP (pointer))
 35420                 pointer = plist_get (XCDR (img->spec), QCpointer);
 35421             }
 35422         }
 35423 #endif  /* HAVE_WINDOW_SYSTEM */
 35424 
 35425       /* Clear mouse face if X/Y not over text.  */
 35426       if (glyph == NULL
 35427           || area != TEXT_AREA
 35428           || !MATRIX_ROW_DISPLAYS_TEXT_P (MATRIX_ROW (w->current_matrix, vpos))
 35429           /* Glyph's OBJECT is nil for glyphs inserted by the
 35430              display engine for its internal purposes, like truncation
 35431              and continuation glyphs and blanks beyond the end of
 35432              line's text on text terminals.  If we are over such a
 35433              glyph, we are not over any text.  */
 35434           || NILP (glyph->object)
 35435           /* R2L rows have a stretch glyph at their front, which
 35436              stands for no text, whereas L2R rows have no glyphs at
 35437              all beyond the end of text.  Treat such stretch glyphs
 35438              like we do with NULL glyphs in L2R rows.  */
 35439           || (MATRIX_ROW (w->current_matrix, vpos)->reversed_p
 35440               && glyph == MATRIX_ROW_GLYPH_START (w->current_matrix, vpos)
 35441               && glyph->type == STRETCH_GLYPH
 35442               && glyph->avoid_cursor_p))
 35443         {
 35444           if (clear_mouse_face (hlinfo))
 35445             cursor = No_Cursor;
 35446           if (FRAME_WINDOW_P (f) && NILP (pointer))
 35447             {
 35448 #ifdef HAVE_WINDOW_SYSTEM
 35449               if (area != TEXT_AREA)
 35450                 cursor = FRAME_OUTPUT_DATA (f)->nontext_cursor;
 35451               else
 35452                 pointer = Vvoid_text_area_pointer;
 35453 #endif
 35454             }
 35455           goto set_cursor;
 35456         }
 35457 
 35458       pos = glyph->charpos;
 35459       object = glyph->object;
 35460       if (!STRINGP (object) && !BUFFERP (object))
 35461         goto set_cursor;
 35462 
 35463       /* If we get an out-of-range value, return now; avoid an error.  */
 35464       if (BUFFERP (object) && pos > BUF_Z (b))
 35465         goto set_cursor;
 35466 
 35467       /* Make the window's buffer temporarily current for
 35468          overlays_at and compute_char_face.  */
 35469       obuf = current_buffer;
 35470       current_buffer = b;
 35471       obegv = BEGV;
 35472       ozv = ZV;
 35473       BEGV = BEG;
 35474       ZV = Z;
 35475 
 35476       /* Is this char mouse-active or does it have help-echo?  */
 35477       position = make_fixnum (pos);
 35478 
 35479       USE_SAFE_ALLOCA;
 35480 
 35481       if (BUFFERP (object))
 35482         {
 35483           /* Put all the overlays we want in a vector in overlay_vec.  */
 35484           GET_OVERLAYS_AT (pos, overlay_vec, noverlays, NULL);
 35485           /* Sort overlays into increasing priority order.  */
 35486           noverlays = sort_overlays (overlay_vec, noverlays, w);
 35487         }
 35488       else
 35489         noverlays = 0;
 35490 
 35491       if (NILP (Vmouse_highlight))
 35492         {
 35493           clear_mouse_face (hlinfo);
 35494           goto check_help_echo;
 35495         }
 35496 
 35497       same_region = coords_in_mouse_face_p (w, hpos, vpos);
 35498 
 35499       if (same_region)
 35500         cursor = No_Cursor;
 35501 
 35502       /* Check mouse-face highlighting.  */
 35503       if (! same_region
 35504           /* If there exists an overlay with mouse-face overlapping
 35505              the one we are currently highlighting, we have to check
 35506              if we enter the overlapping overlay, and then highlight
 35507              only that.  Skip the check when mouse-face highlighting
 35508              is currently hidden to avoid Bug#30519.  */
 35509           || (!hlinfo->mouse_face_hidden
 35510               && OVERLAYP (hlinfo->mouse_face_overlay)
 35511               /* It's possible the overlay was deleted (Bug#35273).  */
 35512               && OVERLAY_BUFFER (hlinfo->mouse_face_overlay)
 35513               && mouse_face_overlay_overlaps (hlinfo->mouse_face_overlay)))
 35514         {
 35515           /* Find the highest priority overlay with a mouse-face.  */
 35516           Lisp_Object overlay = Qnil;
 35517           for (i = noverlays - 1; i >= 0 && NILP (overlay); --i)
 35518             {
 35519               mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
 35520               if (!NILP (mouse_face))
 35521                 overlay = overlay_vec[i];
 35522             }
 35523 
 35524           /* If we're highlighting the same overlay as before, there's
 35525              no need to do that again.  */
 35526           if (!NILP (overlay) && EQ (overlay, hlinfo->mouse_face_overlay))
 35527             goto check_help_echo;
 35528 
 35529           /* Clear the display of the old active region, if any.  */
 35530           if (clear_mouse_face (hlinfo))
 35531             cursor = No_Cursor;
 35532 
 35533           /* Record the overlay, if any, to be highlighted.  */
 35534           hlinfo->mouse_face_overlay = overlay;
 35535 
 35536           /* If no overlay applies, get a text property.  */
 35537           if (NILP (overlay))
 35538             mouse_face = Fget_text_property (position, Qmouse_face, object);
 35539 
 35540           /* Next, compute the bounds of the mouse highlighting and
 35541              display it.  */
 35542           if (!NILP (mouse_face) && STRINGP (object))
 35543             {
 35544               /* The mouse-highlighting comes from a display string
 35545                  with a mouse-face.  */
 35546               Lisp_Object s, e;
 35547               ptrdiff_t ignore;
 35548 
 35549               s = Fprevious_single_property_change
 35550                 (make_fixnum (pos + 1), Qmouse_face, object, Qnil);
 35551               e = Fnext_single_property_change
 35552                 (position, Qmouse_face, object, Qnil);
 35553               if (NILP (s))
 35554                 s = make_fixnum (0);
 35555               if (NILP (e))
 35556                 e = make_fixnum (SCHARS (object));
 35557               mouse_face_from_string_pos (w, hlinfo, object,
 35558                                           XFIXNUM (s), XFIXNUM (e));
 35559               hlinfo->mouse_face_past_end = false;
 35560               hlinfo->mouse_face_window = window;
 35561               hlinfo->mouse_face_face_id
 35562                 = face_at_string_position (w, object, pos, 0, &ignore,
 35563                                            glyph->face_id, true, 0);
 35564               show_mouse_face (hlinfo, DRAW_MOUSE_FACE);
 35565               cursor = No_Cursor;
 35566             }
 35567           else
 35568             {
 35569               /* The mouse-highlighting, if any, comes from an overlay
 35570                  or text property in the buffer.  */
 35571               Lisp_Object buffer UNINIT;
 35572               Lisp_Object disp_string UNINIT;
 35573 
 35574               if (STRINGP (object))
 35575                 {
 35576                   /* If we are on a display string with no mouse-face,
 35577                      check if the text under it has one.  */
 35578                   struct glyph_row *r = MATRIX_ROW (w->current_matrix, vpos);
 35579                   ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
 35580                   pos = string_buffer_position (object, start);
 35581                   if (pos > 0)
 35582                     {
 35583                       mouse_face = get_char_property_and_overlay
 35584                         (make_fixnum (pos), Qmouse_face, w->contents, &overlay);
 35585                       buffer = w->contents;
 35586                       disp_string = object;
 35587                     }
 35588                 }
 35589               else
 35590                 {
 35591                   buffer = object;
 35592                   disp_string = Qnil;
 35593                 }
 35594 
 35595               if (!NILP (mouse_face))
 35596                 {
 35597                   Lisp_Object before, after;
 35598                   Lisp_Object before_string, after_string;
 35599                   /* To correctly find the limits of mouse highlight
 35600                      in a bidi-reordered buffer, we must not use the
 35601                      optimization of limiting the search in
 35602                      previous-single-property-change and
 35603                      next-single-property-change, because
 35604                      rows_from_pos_range needs the real start and end
 35605                      positions to DTRT in this case.  That's because
 35606                      the first row visible in a window does not
 35607                      necessarily display the character whose position
 35608                      is the smallest.  */
 35609                   Lisp_Object lim1
 35610                     = NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
 35611                     ? Fmarker_position (w->start)
 35612                     : Qnil;
 35613                   Lisp_Object lim2
 35614                     = NILP (BVAR (XBUFFER (buffer), bidi_display_reordering))
 35615                     ? make_fixnum (BUF_Z (XBUFFER (buffer))
 35616                                    - w->window_end_pos)
 35617                     : Qnil;
 35618 
 35619                   if (NILP (overlay))
 35620                     {
 35621                       /* Handle the text property case.  */
 35622                       before = Fprevious_single_property_change
 35623                         (make_fixnum (pos + 1), Qmouse_face, buffer, lim1);
 35624                       after = Fnext_single_property_change
 35625                         (make_fixnum (pos), Qmouse_face, buffer, lim2);
 35626                       before_string = after_string = Qnil;
 35627                     }
 35628                   else
 35629                     {
 35630                       /* Handle the overlay case.  */
 35631                       before = Foverlay_start (overlay);
 35632                       after = Foverlay_end (overlay);
 35633                       before_string = Foverlay_get (overlay, Qbefore_string);
 35634                       after_string = Foverlay_get (overlay, Qafter_string);
 35635 
 35636                       if (!STRINGP (before_string)) before_string = Qnil;
 35637                       if (!STRINGP (after_string))  after_string = Qnil;
 35638                     }
 35639 
 35640                   mouse_face_from_buffer_pos (window, hlinfo, pos,
 35641                                               NILP (before)
 35642                                               ? 1
 35643                                               : XFIXNAT (before),
 35644                                               NILP (after)
 35645                                               ? BUF_Z (XBUFFER (buffer))
 35646                                               : XFIXNAT (after),
 35647                                               before_string, after_string,
 35648                                               disp_string);
 35649                   cursor = No_Cursor;
 35650                 }
 35651             }
 35652         }
 35653 
 35654     check_help_echo:
 35655 
 35656       /* Look for a `help-echo' property.  */
 35657       if (NILP (help_echo_string)) {
 35658         Lisp_Object help, overlay;
 35659 
 35660         /* Check overlays first.  */
 35661         help = overlay = Qnil;
 35662         for (i = noverlays - 1; i >= 0 && NILP (help); --i)
 35663           {
 35664             overlay = overlay_vec[i];
 35665             help = Foverlay_get (overlay, Qhelp_echo);
 35666           }
 35667 
 35668         if (!NILP (help))
 35669           {
 35670             help_echo_string = help;
 35671             help_echo_window = window;
 35672             help_echo_object = overlay;
 35673             help_echo_pos = pos;
 35674           }
 35675         else
 35676           {
 35677             Lisp_Object obj = glyph->object;
 35678             ptrdiff_t charpos = glyph->charpos;
 35679 
 35680             /* Try text properties.  */
 35681             if (STRINGP (obj)
 35682                 && charpos >= 0
 35683                 && charpos < SCHARS (obj))
 35684               {
 35685                 help = Fget_text_property (make_fixnum (charpos),
 35686                                            Qhelp_echo, obj);
 35687                 if (NILP (help))
 35688                   {
 35689                     /* If the string itself doesn't specify a help-echo,
 35690                        see if the buffer text ``under'' it does.  */
 35691                     struct glyph_row *r
 35692                       = MATRIX_ROW (w->current_matrix, vpos);
 35693                     ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
 35694                     ptrdiff_t p = string_buffer_position (obj, start);
 35695                     if (p > 0)
 35696                       {
 35697                         help = Fget_char_property (make_fixnum (p),
 35698                                                    Qhelp_echo, w->contents);
 35699                         if (!NILP (help))
 35700                           {
 35701                             charpos = p;
 35702                             obj = w->contents;
 35703                           }
 35704                       }
 35705                   }
 35706               }
 35707             else if (BUFFERP (obj)
 35708                      && charpos >= BEGV
 35709                      && charpos < ZV)
 35710               help = Fget_text_property (make_fixnum (charpos), Qhelp_echo,
 35711                                          obj);
 35712 
 35713             if (!NILP (help))
 35714               {
 35715                 help_echo_string = help;
 35716                 help_echo_window = window;
 35717                 help_echo_object = obj;
 35718                 help_echo_pos = charpos;
 35719               }
 35720           }
 35721       }
 35722 
 35723 #ifdef HAVE_WINDOW_SYSTEM
 35724       /* Look for a `pointer' property.  */
 35725       if (FRAME_WINDOW_P (f) && NILP (pointer))
 35726         {
 35727           /* Check overlays first.  */
 35728           for (i = noverlays - 1; i >= 0 && NILP (pointer); --i)
 35729             pointer = Foverlay_get (overlay_vec[i], Qpointer);
 35730 
 35731           if (NILP (pointer))
 35732             {
 35733               Lisp_Object obj = glyph->object;
 35734               ptrdiff_t charpos = glyph->charpos;
 35735 
 35736               /* Try text properties.  */
 35737               if (STRINGP (obj)
 35738                   && charpos >= 0
 35739                   && charpos < SCHARS (obj))
 35740                 {
 35741                   pointer = Fget_text_property (make_fixnum (charpos),
 35742                                                 Qpointer, obj);
 35743                   if (NILP (pointer))
 35744                     {
 35745                       /* If the string itself doesn't specify a pointer,
 35746                          see if the buffer text ``under'' it does.  */
 35747                       struct glyph_row *r
 35748                         = MATRIX_ROW (w->current_matrix, vpos);
 35749                       ptrdiff_t start = MATRIX_ROW_START_CHARPOS (r);
 35750                       ptrdiff_t p = string_buffer_position (obj, start);
 35751                       if (p > 0)
 35752                         pointer = Fget_char_property (make_fixnum (p),
 35753                                                       Qpointer, w->contents);
 35754                     }
 35755                 }
 35756               else if (BUFFERP (obj)
 35757                        && charpos >= BEGV
 35758                        && charpos < ZV)
 35759                 pointer = Fget_text_property (make_fixnum (charpos),
 35760                                               Qpointer, obj);
 35761             }
 35762         }
 35763 #endif  /* HAVE_WINDOW_SYSTEM */
 35764 
 35765       BEGV = obegv;
 35766       ZV = ozv;
 35767       current_buffer = obuf;
 35768       SAFE_FREE ();
 35769     }
 35770 
 35771  set_cursor:
 35772   define_frame_cursor1 (f, cursor, pointer);
 35773 }
 35774 
 35775 
 35776 /* EXPORT for RIF:
 35777    Clear any mouse-face on window W.  This function is part of the
 35778    redisplay interface, and is called from try_window_id and similar
 35779    functions to ensure the mouse-highlight is off.  */
 35780 
 35781 void
 35782 gui_clear_window_mouse_face (struct window *w)
 35783 {
 35784   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (XFRAME (w->frame));
 35785   Lisp_Object window;
 35786 
 35787   block_input ();
 35788   XSETWINDOW (window, w);
 35789   if (EQ (window, hlinfo->mouse_face_window))
 35790     clear_mouse_face (hlinfo);
 35791   unblock_input ();
 35792 }
 35793 
 35794 
 35795 /* EXPORT:
 35796    Just discard the mouse face information for frame F, if any.
 35797    This is used when the size of F is changed.  */
 35798 
 35799 void
 35800 cancel_mouse_face (struct frame *f)
 35801 {
 35802   Lisp_Object window;
 35803   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 35804 
 35805   window = hlinfo->mouse_face_window;
 35806   if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
 35807     reset_mouse_highlight (hlinfo);
 35808 }
 35809 
 35810 
 35811 
 35812 /***********************************************************************
 35813                            Exposure Events
 35814  ***********************************************************************/
 35815 
 35816 #ifdef HAVE_WINDOW_SYSTEM
 35817 
 35818 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
 35819    which intersects rectangle R.  R is in window-relative coordinates.  */
 35820 
 35821 static void
 35822 expose_area (struct window *w, struct glyph_row *row, const Emacs_Rectangle *r,
 35823              enum glyph_row_area area)
 35824 {
 35825   struct glyph *first = row->glyphs[area];
 35826   struct glyph *end = row->glyphs[area] + row->used[area];
 35827   struct glyph *last;
 35828   int first_x, start_x, x;
 35829 
 35830   if (area == TEXT_AREA && row->fill_line_p)
 35831     /* If row extends face to end of line write the whole line.  */
 35832     draw_glyphs (w, row->x, row, area,
 35833                  0, row->used[area],
 35834                  DRAW_NORMAL_TEXT, 0);
 35835   else
 35836     {
 35837       /* Set START_X to the window-relative start position for drawing glyphs of
 35838          AREA.  The first glyph of the text area can be partially visible.
 35839          The first glyphs of other areas cannot.  */
 35840       start_x = window_box_left_offset (w, area);
 35841       x = start_x;
 35842       if (area == TEXT_AREA)
 35843         x += row->x;
 35844 
 35845       /* Find the first glyph that must be redrawn.  */
 35846       while (first < end
 35847              && x + first->pixel_width < r->x)
 35848         {
 35849           x += first->pixel_width;
 35850           ++first;
 35851         }
 35852 
 35853       /* Find the last one.  */
 35854       last = first;
 35855       first_x = x;
 35856       /* Use a signed int intermediate value to avoid catastrophic
 35857          failures due to comparison between signed and unsigned, when
 35858          x is negative (can happen for wide images that are hscrolled).  */
 35859       int r_end = r->x + r->width;
 35860       while (last < end && x < r_end)
 35861         {
 35862           x += last->pixel_width;
 35863           ++last;
 35864         }
 35865 
 35866       /* Repaint.  */
 35867       if (last > first)
 35868         draw_glyphs (w, first_x - start_x, row, area,
 35869                      first - row->glyphs[area], last - row->glyphs[area],
 35870                      DRAW_NORMAL_TEXT, 0);
 35871     }
 35872 }
 35873 
 35874 
 35875 /* Redraw the parts of the glyph row ROW on window W intersecting
 35876    rectangle R.  R is in window-relative coordinates.  Value is
 35877    true if mouse-face was overwritten.  */
 35878 
 35879 static bool
 35880 expose_line (struct window *w, struct glyph_row *row, const Emacs_Rectangle *r)
 35881 {
 35882   eassert (row->enabled_p);
 35883 
 35884   if (row->mode_line_p || w->pseudo_window_p)
 35885     draw_glyphs (w, 0, row, TEXT_AREA,
 35886                  0, row->used[TEXT_AREA],
 35887                  DRAW_NORMAL_TEXT, 0);
 35888   else
 35889     {
 35890       if (row->used[LEFT_MARGIN_AREA])
 35891         expose_area (w, row, r, LEFT_MARGIN_AREA);
 35892       if (row->used[TEXT_AREA])
 35893         expose_area (w, row, r, TEXT_AREA);
 35894       if (row->used[RIGHT_MARGIN_AREA])
 35895         expose_area (w, row, r, RIGHT_MARGIN_AREA);
 35896       draw_row_fringe_bitmaps (w, row);
 35897     }
 35898 
 35899   return row->mouse_face_p;
 35900 }
 35901 
 35902 
 35903 /* Redraw those parts of glyphs rows during expose event handling that
 35904    overlap other rows.  Redrawing of an exposed line writes over parts
 35905    of lines overlapping that exposed line; this function fixes that.
 35906 
 35907    W is the window being exposed.  FIRST_OVERLAPPING_ROW is the first
 35908    row in W's current matrix that is exposed and overlaps other rows.
 35909    LAST_OVERLAPPING_ROW is the last such row.  */
 35910 
 35911 static void
 35912 expose_overlaps (struct window *w,
 35913                  struct glyph_row *first_overlapping_row,
 35914                  struct glyph_row *last_overlapping_row,
 35915                  const Emacs_Rectangle *r)
 35916 {
 35917   struct glyph_row *row;
 35918 
 35919   for (row = first_overlapping_row; row <= last_overlapping_row; ++row)
 35920     if (row->overlapping_p)
 35921       {
 35922         eassert (row->enabled_p && !row->mode_line_p);
 35923 
 35924         row->clip = r;
 35925         if (row->used[LEFT_MARGIN_AREA])
 35926           gui_fix_overlapping_area (w, row, LEFT_MARGIN_AREA, OVERLAPS_BOTH);
 35927 
 35928         if (row->used[TEXT_AREA])
 35929           gui_fix_overlapping_area (w, row, TEXT_AREA, OVERLAPS_BOTH);
 35930 
 35931         if (row->used[RIGHT_MARGIN_AREA])
 35932           gui_fix_overlapping_area (w, row, RIGHT_MARGIN_AREA, OVERLAPS_BOTH);
 35933         row->clip = NULL;
 35934       }
 35935 }
 35936 
 35937 
 35938 /* Return true if W's cursor intersects rectangle R.  */
 35939 
 35940 static bool
 35941 phys_cursor_in_rect_p (struct window *w, const Emacs_Rectangle *r)
 35942 {
 35943   Emacs_Rectangle cr, result;
 35944   struct glyph *cursor_glyph;
 35945   struct glyph_row *row;
 35946 
 35947   if (w->phys_cursor.vpos >= 0
 35948       && w->phys_cursor.vpos < w->current_matrix->nrows
 35949       && (row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos),
 35950           row->enabled_p)
 35951       && row->cursor_in_fringe_p)
 35952     {
 35953       /* Cursor is in the fringe.  */
 35954       cr.x = window_box_right_offset (w,
 35955                                       (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
 35956                                        ? RIGHT_MARGIN_AREA
 35957                                        : TEXT_AREA));
 35958       cr.y = row->y;
 35959       cr.width = WINDOW_RIGHT_FRINGE_WIDTH (w);
 35960       cr.height = row->height;
 35961       return gui_intersect_rectangles (&cr, r, &result);
 35962     }
 35963 
 35964   cursor_glyph = get_phys_cursor_glyph (w);
 35965   if (cursor_glyph)
 35966     {
 35967       /* r is relative to W's box, but w->phys_cursor.x is relative
 35968          to left edge of W's TEXT area.  Adjust it.  */
 35969       cr.x = window_box_left_offset (w, TEXT_AREA) + w->phys_cursor.x;
 35970       cr.y = w->phys_cursor.y;
 35971       cr.width = cursor_glyph->pixel_width;
 35972       cr.height = w->phys_cursor_height;
 35973       /* ++KFS: W32 version used W32-specific IntersectRect here, but
 35974          I assume the effect is the same -- and this is portable.  */
 35975       return gui_intersect_rectangles (&cr, r, &result);
 35976     }
 35977   /* If we don't understand the format, pretend we're not in the hot-spot.  */
 35978   return false;
 35979 }
 35980 
 35981 
 35982 /* EXPORT:
 35983    Draw a vertical window border to the right of window W if W doesn't
 35984    have vertical scroll bars.  */
 35985 
 35986 void
 35987 gui_draw_vertical_border (struct window *w)
 35988 {
 35989   struct frame *f = XFRAME (WINDOW_FRAME (w));
 35990 
 35991   /* We could do better, if we knew what type of scroll-bar the adjacent
 35992      windows (on either side) have...  But we don't :-(
 35993      However, I think this works ok.  ++KFS 2003-04-25 */
 35994 
 35995   /* Redraw borders between horizontally adjacent windows.  Don't
 35996      do it for frames with vertical scroll bars because either the
 35997      right scroll bar of a window, or the left scroll bar of its
 35998      neighbor will suffice as a border.  */
 35999   if (FRAME_HAS_VERTICAL_SCROLL_BARS (f) || FRAME_RIGHT_DIVIDER_WIDTH (f))
 36000     return;
 36001 
 36002   /* Note: It is necessary to redraw both the left and the right
 36003      borders, for when only this single window W is being
 36004      redisplayed.  */
 36005   if (!WINDOW_RIGHTMOST_P (w)
 36006       && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
 36007     {
 36008       int x0, x1, y0, y1;
 36009 
 36010       window_box_edges (w, &x0, &y0, &x1, &y1);
 36011       y1 -= 1;
 36012 
 36013       if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
 36014         x1 -= 1;
 36015 
 36016       FRAME_RIF (f)->draw_vertical_window_border (w, x1, y0, y1);
 36017     }
 36018 
 36019   if (!WINDOW_LEFTMOST_P (w)
 36020       && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
 36021     {
 36022       int x0, x1, y0, y1;
 36023 
 36024       window_box_edges (w, &x0, &y0, &x1, &y1);
 36025       y1 -= 1;
 36026 
 36027       if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
 36028         x0 -= 1;
 36029 
 36030       FRAME_RIF (f)->draw_vertical_window_border (w, x0, y0, y1);
 36031     }
 36032 }
 36033 
 36034 
 36035 /* Draw window dividers for window W.  */
 36036 
 36037 void
 36038 gui_draw_right_divider (struct window *w)
 36039 {
 36040   struct frame *f = WINDOW_XFRAME (w);
 36041 
 36042   if (w->mini || w->pseudo_window_p)
 36043     return;
 36044   else if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
 36045     {
 36046       int x0 = WINDOW_RIGHT_EDGE_X (w) - WINDOW_RIGHT_DIVIDER_WIDTH (w);
 36047       int x1 = WINDOW_RIGHT_EDGE_X (w);
 36048       int y0 = WINDOW_TOP_EDGE_Y (w);
 36049       int y1 = WINDOW_BOTTOM_EDGE_Y (w);
 36050 
 36051       /* If W is horizontally combined and has a right sibling, don't
 36052          draw over any bottom divider.  */
 36053       if (WINDOW_BOTTOM_DIVIDER_WIDTH (w)
 36054           && !NILP (w->parent)
 36055           && WINDOW_HORIZONTAL_COMBINATION_P (XWINDOW (w->parent))
 36056           && !NILP (w->next))
 36057         y1 -= WINDOW_BOTTOM_DIVIDER_WIDTH (w);
 36058 
 36059       FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
 36060     }
 36061 }
 36062 
 36063 static void
 36064 gui_draw_bottom_divider (struct window *w)
 36065 {
 36066   struct frame *f = XFRAME (WINDOW_FRAME (w));
 36067 
 36068   if (w->mini || w->pseudo_window_p)
 36069     return;
 36070   else if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
 36071     {
 36072       int x0 = WINDOW_LEFT_EDGE_X (w);
 36073       int x1 = WINDOW_RIGHT_EDGE_X (w);
 36074       int y0 = WINDOW_BOTTOM_EDGE_Y (w) - WINDOW_BOTTOM_DIVIDER_WIDTH (w);
 36075       int y1 = WINDOW_BOTTOM_EDGE_Y (w);
 36076       struct window *p = !NILP (w->parent) ? XWINDOW (w->parent) : NULL;
 36077 
 36078       /* If W is vertically combined and has a sibling below, don't draw
 36079          over any right divider.  */
 36080       if (WINDOW_RIGHT_DIVIDER_WIDTH (w)
 36081           && p
 36082           && ((WINDOW_VERTICAL_COMBINATION_P (p)
 36083                && !NILP (w->next))
 36084               || (WINDOW_HORIZONTAL_COMBINATION_P (p)
 36085                   && NILP (w->next)
 36086                   && !NILP (p->parent)
 36087                   && WINDOW_VERTICAL_COMBINATION_P (XWINDOW (p->parent))
 36088                   && !NILP (XWINDOW (p->parent)->next))))
 36089         x1 -= WINDOW_RIGHT_DIVIDER_WIDTH (w);
 36090 
 36091       FRAME_RIF (f)->draw_window_divider (w, x0, x1, y0, y1);
 36092     }
 36093 }
 36094 
 36095 /* Redraw the part of window W intersection rectangle FR.  Pixel
 36096    coordinates in FR are frame-relative.  Call this function with
 36097    input blocked.  Value is true if the exposure overwrites
 36098    mouse-face.  */
 36099 
 36100 static bool
 36101 expose_window (struct window *w, const Emacs_Rectangle *fr)
 36102 {
 36103   struct frame *f = XFRAME (w->frame);
 36104   Emacs_Rectangle wr, r;
 36105   bool mouse_face_overwritten_p = false;
 36106 
 36107   /* If window is not yet fully initialized, do nothing.  This can
 36108      happen when toolkit scroll bars are used and a window is split.
 36109      Reconfiguring the scroll bar will generate an expose for a newly
 36110      created window.  */
 36111   if (w->current_matrix == NULL)
 36112     return false;
 36113 
 36114   /* When we're currently updating the window, display and current
 36115      matrix usually don't agree.  Arrange for a thorough display
 36116      later.  */
 36117   if (w->must_be_updated_p)
 36118     {
 36119       SET_FRAME_GARBAGED (f);
 36120       return false;
 36121     }
 36122 
 36123   /* Frame-relative pixel rectangle of W.  */
 36124   wr.x = WINDOW_LEFT_EDGE_X (w);
 36125   wr.y = WINDOW_TOP_EDGE_Y (w);
 36126   wr.width = WINDOW_PIXEL_WIDTH (w);
 36127   wr.height = WINDOW_PIXEL_HEIGHT (w);
 36128 
 36129   if (gui_intersect_rectangles (fr, &wr, &r))
 36130     {
 36131       int yb = window_text_bottom_y (w);
 36132       struct glyph_row *row;
 36133       struct glyph_row *first_overlapping_row, *last_overlapping_row;
 36134 
 36135       redisplay_trace ("expose_window (%d, %d, %u, %u)\n",
 36136                        r.x, r.y, r.width, r.height);
 36137 
 36138       /* Convert to window coordinates.  */
 36139       r.x -= WINDOW_LEFT_EDGE_X (w);
 36140       r.y -= WINDOW_TOP_EDGE_Y (w);
 36141 
 36142       /* Turn off the cursor.  */
 36143       bool cursor_cleared_p = (!w->pseudo_window_p
 36144                                && phys_cursor_in_rect_p (w, &r));
 36145       if (cursor_cleared_p)
 36146         gui_clear_cursor (w);
 36147 
 36148       /* If the row containing the cursor extends face to end of line,
 36149          then expose_area might overwrite the cursor outside the
 36150          rectangle and thus notice_overwritten_cursor might clear
 36151          w->phys_cursor_on_p.  We remember the original value and
 36152          check later if it is changed.  */
 36153       bool phys_cursor_on_p = w->phys_cursor_on_p;
 36154 
 36155       /* Use a signed int intermediate value to avoid catastrophic
 36156          failures due to comparison between signed and unsigned, when
 36157          y0 or y1 is negative (can happen for tall images).  */
 36158       int r_bottom = r.y + r.height;
 36159 
 36160       /* We must temporarily switch to the window's buffer, in case
 36161          the fringe face has been remapped in that buffer's
 36162          face-remapping-alist, so that draw_row_fringe_bitmaps,
 36163          called from expose_line, will use the right face.  */
 36164       bool buffer_changed = false;
 36165       struct buffer *oldbuf = current_buffer;
 36166       if (!w->pseudo_window_p)
 36167         {
 36168           set_buffer_internal_1 (XBUFFER (w->contents));
 36169           buffer_changed = true;
 36170         }
 36171 
 36172       /* Update lines intersecting rectangle R.  */
 36173       first_overlapping_row = last_overlapping_row = NULL;
 36174       for (row = w->current_matrix->rows;
 36175            row->enabled_p;
 36176            ++row)
 36177         {
 36178           int y0 = row->y;
 36179           int y1 = MATRIX_ROW_BOTTOM_Y (row);
 36180 
 36181           if ((y0 >= r.y && y0 < r_bottom)
 36182               || (y1 > r.y && y1 < r_bottom)
 36183               || (r.y >= y0 && r.y < y1)
 36184               || (r_bottom > y0 && r_bottom < y1))
 36185             {
 36186               /* A header line may be overlapping, but there is no need
 36187                  to fix overlapping areas for them.  KFS 2005-02-12 */
 36188               if (row->overlapping_p && !row->mode_line_p)
 36189                 {
 36190                   if (first_overlapping_row == NULL)
 36191                     first_overlapping_row = row;
 36192                   last_overlapping_row = row;
 36193                 }
 36194 
 36195               row->clip = fr;
 36196               if (expose_line (w, row, &r))
 36197                 mouse_face_overwritten_p = true;
 36198               row->clip = NULL;
 36199             }
 36200           else if (row->overlapping_p)
 36201             {
 36202               /* We must redraw a row overlapping the exposed area.  */
 36203               if (y0 < r.y
 36204                   ? y0 + row->phys_height > r.y
 36205                   : y0 + row->ascent - row->phys_ascent < r.y +r.height)
 36206                 {
 36207                   if (first_overlapping_row == NULL)
 36208                     first_overlapping_row = row;
 36209                   last_overlapping_row = row;
 36210                 }
 36211             }
 36212 
 36213           if (y1 >= yb)
 36214             break;
 36215         }
 36216 
 36217       if (buffer_changed)
 36218         set_buffer_internal_1 (oldbuf);
 36219 
 36220       /* Display the mode line if there is one.  */
 36221       if (window_wants_mode_line (w)
 36222           && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
 36223               row->enabled_p)
 36224           && row->y < r_bottom)
 36225         {
 36226           if (expose_line (w, row, &r))
 36227             mouse_face_overwritten_p = true;
 36228         }
 36229 
 36230       if (!w->pseudo_window_p)
 36231         {
 36232           /* Fix the display of overlapping rows.  */
 36233           if (first_overlapping_row)
 36234             expose_overlaps (w, first_overlapping_row, last_overlapping_row,
 36235                              fr);
 36236 
 36237           /* Draw border between windows.  */
 36238           if (WINDOW_RIGHT_DIVIDER_WIDTH (w))
 36239             gui_draw_right_divider (w);
 36240           else
 36241             gui_draw_vertical_border (w);
 36242 
 36243           if (WINDOW_BOTTOM_DIVIDER_WIDTH (w))
 36244             gui_draw_bottom_divider (w);
 36245 
 36246           /* Turn the cursor on again.  */
 36247           if (cursor_cleared_p
 36248               || (phys_cursor_on_p && !w->phys_cursor_on_p))
 36249             update_window_cursor (w, true);
 36250         }
 36251     }
 36252 
 36253   return mouse_face_overwritten_p;
 36254 }
 36255 
 36256 
 36257 
 36258 /* Redraw (parts) of all windows in the window tree rooted at W that
 36259    intersect R.  R contains frame pixel coordinates.  Value is
 36260    true if the exposure overwrites mouse-face.  */
 36261 
 36262 static bool
 36263 expose_window_tree (struct window *w, const Emacs_Rectangle *r)
 36264 {
 36265   struct frame *f = XFRAME (w->frame);
 36266   bool mouse_face_overwritten_p = false;
 36267 
 36268   while (w && !FRAME_GARBAGED_P (f))
 36269     {
 36270       mouse_face_overwritten_p
 36271         |= (WINDOWP (w->contents)
 36272             ? expose_window_tree (XWINDOW (w->contents), r)
 36273             : expose_window (w, r));
 36274 
 36275       w = NILP (w->next) ? NULL : XWINDOW (w->next);
 36276     }
 36277 
 36278   return mouse_face_overwritten_p;
 36279 }
 36280 
 36281 
 36282 /* EXPORT:
 36283    Redisplay an exposed area of frame F.  X and Y are the upper-left
 36284    corner of the exposed rectangle.  W and H are width and height of
 36285    the exposed area.  All are pixel values.  W or H zero means redraw
 36286    the entire frame.  */
 36287 
 36288 void
 36289 expose_frame (struct frame *f, int x, int y, int w, int h)
 36290 {
 36291   Emacs_Rectangle r;
 36292   bool mouse_face_overwritten_p = false;
 36293 
 36294   if (FRAME_GARBAGED_P (f))
 36295     {
 36296       redisplay_trace ("expose_frame garbaged\n");
 36297       return;
 36298     }
 36299 
 36300   /* If basic faces haven't been realized yet, there is no point in
 36301      trying to redraw anything.  This can happen when we get an expose
 36302      event while Emacs is starting, e.g. by moving another window.  */
 36303   if (FRAME_FACE_CACHE (f) == NULL
 36304       || FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
 36305     {
 36306       redisplay_trace ("expose_frame no faces\n");
 36307       return;
 36308     }
 36309 
 36310   if (w == 0 || h == 0)
 36311     {
 36312       r.x = r.y = 0;
 36313       r.width = FRAME_TEXT_WIDTH (f);
 36314       r.height = FRAME_TEXT_HEIGHT (f);
 36315     }
 36316   else
 36317     {
 36318       r.x = x;
 36319       r.y = y;
 36320       r.width = w;
 36321       r.height = h;
 36322     }
 36323 
 36324   redisplay_trace ("expose_frame (%d, %d, %u, %u)\n",
 36325                    r.x, r.y, r.width, r.height);
 36326   mouse_face_overwritten_p = expose_window_tree (XWINDOW (f->root_window), &r);
 36327 
 36328   if (WINDOWP (f->tab_bar_window))
 36329     mouse_face_overwritten_p
 36330       |= expose_window (XWINDOW (f->tab_bar_window), &r);
 36331 
 36332 #ifndef HAVE_EXT_TOOL_BAR
 36333   if (WINDOWP (f->tool_bar_window))
 36334     mouse_face_overwritten_p
 36335       |= expose_window (XWINDOW (f->tool_bar_window), &r);
 36336 #endif
 36337 
 36338 #ifdef HAVE_X_WINDOWS
 36339 #ifndef MSDOS
 36340 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
 36341   if (WINDOWP (f->menu_bar_window))
 36342     mouse_face_overwritten_p
 36343       |= expose_window (XWINDOW (f->menu_bar_window), &r);
 36344 #endif /* not USE_X_TOOLKIT and not USE_GTK */
 36345 #endif
 36346 #endif
 36347 
 36348   /* Some window managers support a focus-follows-mouse style with
 36349      delayed raising of frames.  Imagine a partially obscured frame,
 36350      and moving the mouse into partially obscured mouse-face on that
 36351      frame.  The visible part of the mouse-face will be highlighted,
 36352      then the WM raises the obscured frame.  With at least one WM, KDE
 36353      2.1, Emacs is not getting any event for the raising of the frame
 36354      (even tried with SubstructureRedirectMask), only Expose events.
 36355      These expose events will draw text normally, i.e. not
 36356      highlighted.  Which means we must redo the highlight here.
 36357      Subsume it under ``we love X''.  --gerd 2001-08-15  */
 36358   /* Included in Windows version because Windows most likely does not
 36359      do the right thing if any third party tool offers
 36360      focus-follows-mouse with delayed raise.  --jason 2001-10-12  */
 36361   if (mouse_face_overwritten_p && !FRAME_GARBAGED_P (f))
 36362     {
 36363       Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 36364       if (f == hlinfo->mouse_face_mouse_frame)
 36365         {
 36366           int mouse_x = hlinfo->mouse_face_mouse_x;
 36367           int mouse_y = hlinfo->mouse_face_mouse_y;
 36368           clear_mouse_face (hlinfo);
 36369           note_mouse_highlight (f, mouse_x, mouse_y);
 36370         }
 36371     }
 36372 }
 36373 
 36374 
 36375 /* EXPORT:
 36376    Determine the intersection of two rectangles R1 and R2.  Return
 36377    the intersection in *RESULT.  Value is true if RESULT is not
 36378    empty.  */
 36379 
 36380 bool
 36381 gui_intersect_rectangles (const Emacs_Rectangle *r1, const Emacs_Rectangle *r2,
 36382                           Emacs_Rectangle *result)
 36383 {
 36384   const Emacs_Rectangle *left, *right;
 36385   const Emacs_Rectangle *upper, *lower;
 36386   bool intersection_p = false;
 36387 
 36388   /* Rearrange so that R1 is the left-most rectangle.  */
 36389   if (r1->x < r2->x)
 36390     left = r1, right = r2;
 36391   else
 36392     left = r2, right = r1;
 36393 
 36394   /* X0 of the intersection is right.x0, if this is inside R1,
 36395      otherwise there is no intersection.  */
 36396   if (right->x <= left->x + left->width)
 36397     {
 36398       result->x = right->x;
 36399 
 36400       /* The right end of the intersection is the minimum of
 36401          the right ends of left and right.  */
 36402       result->width = (min (left->x + left->width, right->x + right->width)
 36403                        - result->x);
 36404 
 36405       /* Same game for Y.  */
 36406       if (r1->y < r2->y)
 36407         upper = r1, lower = r2;
 36408       else
 36409         upper = r2, lower = r1;
 36410 
 36411       /* The upper end of the intersection is lower.y0, if this is inside
 36412          of upper.  Otherwise, there is no intersection.  */
 36413       if (lower->y <= upper->y + upper->height)
 36414         {
 36415           result->y = lower->y;
 36416 
 36417           /* The lower end of the intersection is the minimum of the lower
 36418              ends of upper and lower.  */
 36419           result->height = (min (lower->y + lower->height,
 36420                                  upper->y + upper->height)
 36421                             - result->y);
 36422           intersection_p = true;
 36423         }
 36424     }
 36425 
 36426   return intersection_p;
 36427 }
 36428 
 36429 #endif /* HAVE_WINDOW_SYSTEM */
 36430 
 36431 
 36432 /***********************************************************************
 36433                             Initialization
 36434  ***********************************************************************/
 36435 
 36436 void
 36437 syms_of_xdisp (void)
 36438 {
 36439   Vwith_echo_area_save_vector = Qnil;
 36440   staticpro (&Vwith_echo_area_save_vector);
 36441 
 36442   Vmessage_stack = Qnil;
 36443   staticpro (&Vmessage_stack);
 36444 
 36445   /* Non-nil means don't actually do any redisplay.  */
 36446   DEFSYM (Qinhibit_redisplay, "inhibit-redisplay");
 36447 
 36448   DEFSYM (Qredisplay_internal_xC_functionx, "redisplay_internal (C function)");
 36449 
 36450   DEFVAR_BOOL ("scroll-minibuffer-conservatively",
 36451                scroll_minibuffer_conservatively,
 36452                doc: /* Non-nil means scroll conservatively in minibuffer windows.
 36453 When the value is nil, scrolling in minibuffer windows obeys the
 36454 settings of `scroll-conservatively'.  */);
 36455   scroll_minibuffer_conservatively = true; /* bug#44070 */
 36456 
 36457   DEFVAR_BOOL ("inhibit-message", inhibit_message,
 36458               doc:  /* Non-nil means calls to `message' are not displayed.
 36459 They are still logged to the *Messages* buffer.
 36460 
 36461 Do NOT set this globally to a non-nil value, as doing that will
 36462 disable messages everywhere, including in I-search and other
 36463 places where they are necessary.  This variable is intended to
 36464 be let-bound around code that needs to disable messages temporarily. */);
 36465   inhibit_message = false;
 36466 
 36467   message_dolog_marker1 = Fmake_marker ();
 36468   staticpro (&message_dolog_marker1);
 36469   message_dolog_marker2 = Fmake_marker ();
 36470   staticpro (&message_dolog_marker2);
 36471   message_dolog_marker3 = Fmake_marker ();
 36472   staticpro (&message_dolog_marker3);
 36473 
 36474   defsubr (&Sset_buffer_redisplay);
 36475 #ifdef GLYPH_DEBUG
 36476   defsubr (&Sdump_frame_glyph_matrix);
 36477   defsubr (&Sdump_glyph_matrix);
 36478   defsubr (&Sdump_glyph_row);
 36479   defsubr (&Sdump_tab_bar_row);
 36480   defsubr (&Sdump_tool_bar_row);
 36481   defsubr (&Strace_redisplay);
 36482   defsubr (&Strace_to_stderr);
 36483 #endif
 36484 #ifdef HAVE_WINDOW_SYSTEM
 36485   defsubr (&Stab_bar_height);
 36486   defsubr (&Stool_bar_height);
 36487   defsubr (&Slookup_image_map);
 36488 #endif
 36489   defsubr (&Sline_pixel_height);
 36490   defsubr (&Sformat_mode_line);
 36491   defsubr (&Sinvisible_p);
 36492   defsubr (&Scurrent_bidi_paragraph_direction);
 36493   defsubr (&Swindow_text_pixel_size);
 36494   defsubr (&Sbuffer_text_pixel_size);
 36495   defsubr (&Smove_point_visually);
 36496   defsubr (&Sbidi_find_overridden_directionality);
 36497   defsubr (&Sdisplay__line_is_continued_p);
 36498   defsubr (&Sget_display_property);
 36499   defsubr (&Slong_line_optimizations_p);
 36500 
 36501   DEFSYM (Qmenu_bar_update_hook, "menu-bar-update-hook");
 36502   DEFSYM (Qoverriding_terminal_local_map, "overriding-terminal-local-map");
 36503   DEFSYM (Qoverriding_local_map, "overriding-local-map");
 36504   DEFSYM (Qwindow_scroll_functions, "window-scroll-functions");
 36505   DEFSYM (Qinhibit_point_motion_hooks, "inhibit-point-motion-hooks");
 36506   DEFSYM (Qeval, "eval");
 36507   DEFSYM (QCdata, ":data");
 36508 
 36509   /* Names of text properties relevant for redisplay.  */
 36510   DEFSYM (Qdisplay, "display");
 36511   DEFSYM (Qspace_width, "space-width");
 36512   DEFSYM (Qraise, "raise");
 36513   DEFSYM (Qslice, "slice");
 36514   DEFSYM (Qspace, "space");
 36515   DEFSYM (Qmargin, "margin");
 36516   DEFSYM (Qpointer, "pointer");
 36517   DEFSYM (Qleft_margin, "left-margin");
 36518   DEFSYM (Qright_margin, "right-margin");
 36519   DEFSYM (Qcenter, "center");
 36520   DEFSYM (Qline_height, "line-height");
 36521   DEFSYM (QCalign_to, ":align-to");
 36522   DEFSYM (QCrelative_width, ":relative-width");
 36523   DEFSYM (QCrelative_height, ":relative-height");
 36524   DEFSYM (QCeval, ":eval");
 36525   DEFSYM (QCpropertize, ":propertize");
 36526   DEFSYM (QCfile, ":file");
 36527   DEFSYM (Qfontified, "fontified");
 36528   DEFSYM (Qfontification_functions, "fontification-functions");
 36529   DEFSYM (Qlong_line_optimizations_in_fontification_functions,
 36530           "long-line-optimizations-in-fontification-functions");
 36531 
 36532   /* Name of the symbol which disables Lisp evaluation in 'display'
 36533      properties.  This is used by enriched.el.  */
 36534   DEFSYM (Qdisable_eval, "disable-eval");
 36535 
 36536   /* Name of the face used to highlight trailing whitespace.  */
 36537   DEFSYM (Qtrailing_whitespace, "trailing-whitespace");
 36538 
 36539   /* Names of the faces used to display line numbers.  */
 36540   DEFSYM (Qline_number, "line-number");
 36541   DEFSYM (Qline_number_current_line, "line-number-current-line");
 36542   DEFSYM (Qline_number_major_tick, "line-number-major-tick");
 36543   DEFSYM (Qline_number_minor_tick, "line-number-minor-tick");
 36544   /* Name of a text property which disables line-number display.  */
 36545   DEFSYM (Qdisplay_line_numbers_disable, "display-line-numbers-disable");
 36546 
 36547   /* Name of the face used to display fill column indicator character.  */
 36548   DEFSYM (Qfill_column_indicator, "fill-column-indicator");
 36549 
 36550   /* Name and number of the face used to highlight escape glyphs.  */
 36551   DEFSYM (Qescape_glyph, "escape-glyph");
 36552 
 36553   /* Name and number of the face used to highlight non-breaking
 36554      spaces/hyphens.  */
 36555   DEFSYM (Qnobreak_space, "nobreak-space");
 36556   DEFSYM (Qnobreak_hyphen, "nobreak-hyphen");
 36557 
 36558   /* The symbol 'image' which is the car of the lists used to represent
 36559      images in Lisp.  Also a tool bar style.  */
 36560   DEFSYM (Qimage, "image");
 36561 
 36562   /* Tool bar styles.  */
 36563   DEFSYM (Qtext, "text");
 36564   DEFSYM (Qboth, "both");
 36565   DEFSYM (Qboth_horiz, "both-horiz");
 36566   DEFSYM (Qtext_image_horiz, "text-image-horiz");
 36567 
 36568   /* The image map types.  */
 36569   DEFSYM (QCmap, ":map");
 36570   DEFSYM (QCpointer, ":pointer");
 36571   DEFSYM (Qrect, "rect");
 36572   DEFSYM (Qcircle, "circle");
 36573   DEFSYM (Qpoly, "poly");
 36574 
 36575   DEFSYM (Qinhibit_menubar_update, "inhibit-menubar-update");
 36576 
 36577   DEFSYM (Qgrow_only, "grow-only");
 36578   DEFSYM (Qinhibit_eval_during_redisplay, "inhibit-eval-during-redisplay");
 36579   DEFSYM (Qposition, "position");
 36580   DEFSYM (Qbuffer_position, "buffer-position");
 36581   DEFSYM (Qobject, "object");
 36582 
 36583   /* Cursor shapes.  */
 36584   DEFSYM (Qbar, "bar");
 36585   DEFSYM (Qhbar, "hbar");
 36586   DEFSYM (Qbox, "box");
 36587   DEFSYM (Qhollow, "hollow");
 36588 
 36589   /* Pointer shapes.  */
 36590   DEFSYM (Qhand, "hand");
 36591   DEFSYM (Qarrow, "arrow");
 36592   /* also Qtext */
 36593 
 36594   DEFSYM (Qdragging, "dragging");
 36595   DEFSYM (Qdropping, "dropping");
 36596   DEFSYM (Qdrag_source, "drag-source");
 36597 
 36598   DEFSYM (Qdrag_with_mode_line, "drag-with-mode-line");
 36599   DEFSYM (Qdrag_with_header_line, "drag-with-header-line");
 36600   DEFSYM (Qdrag_with_tab_line, "drag-with-tab-line");
 36601 
 36602   DEFSYM (Qinhibit_free_realized_faces, "inhibit-free-realized-faces");
 36603 
 36604   list_of_error = list1 (Qerror);
 36605   staticpro (&list_of_error);
 36606 
 36607   /* Values of those variables at last redisplay are stored as
 36608      properties on 'overlay-arrow-position' symbol.  However, if
 36609      Voverlay_arrow_position is a marker, last-arrow-position is its
 36610      numerical position.  */
 36611   DEFSYM (Qlast_arrow_position, "last-arrow-position");
 36612   DEFSYM (Qlast_arrow_string, "last-arrow-string");
 36613 
 36614   /* Alternative overlay-arrow-string and overlay-arrow-bitmap
 36615      properties on a symbol in overlay-arrow-variable-list.  */
 36616   DEFSYM (Qoverlay_arrow_string, "overlay-arrow-string");
 36617   DEFSYM (Qoverlay_arrow_bitmap, "overlay-arrow-bitmap");
 36618 
 36619   echo_buffer[0] = echo_buffer[1] = Qnil;
 36620   staticpro (&echo_buffer[0]);
 36621   staticpro (&echo_buffer[1]);
 36622 
 36623   echo_area_buffer[0] = echo_area_buffer[1] = Qnil;
 36624   staticpro (&echo_area_buffer[0]);
 36625   staticpro (&echo_area_buffer[1]);
 36626 
 36627   DEFVAR_LISP ("messages-buffer-name", Vmessages_buffer_name,
 36628     doc: /* The name of the buffer where messages are logged.
 36629 This is normally \"\*Messages*\", but can be rebound by packages that
 36630 wish to redirect messages to a different buffer.  (If the buffer
 36631 doesn't exist, it will be created and put into
 36632 `messages-buffer-mode'.)  */);
 36633   Vmessages_buffer_name = build_string ("*Messages*");
 36634 
 36635   mode_line_proptrans_alist = Qnil;
 36636   staticpro (&mode_line_proptrans_alist);
 36637   mode_line_string_list = Qnil;
 36638   staticpro (&mode_line_string_list);
 36639   mode_line_string_face = Qnil;
 36640   staticpro (&mode_line_string_face);
 36641   mode_line_string_face_prop = Qnil;
 36642   staticpro (&mode_line_string_face_prop);
 36643   Vmode_line_unwind_vector = Qnil;
 36644   staticpro (&Vmode_line_unwind_vector);
 36645 
 36646   DEFSYM (Qmode_line_default_help_echo, "mode-line-default-help-echo");
 36647 
 36648   help_echo_string = Qnil;
 36649   staticpro (&help_echo_string);
 36650   help_echo_object = Qnil;
 36651   staticpro (&help_echo_object);
 36652   help_echo_window = Qnil;
 36653   staticpro (&help_echo_window);
 36654   previous_help_echo_string = Qnil;
 36655   staticpro (&previous_help_echo_string);
 36656   help_echo_pos = -1;
 36657 
 36658   DEFSYM (Qright_to_left, "right-to-left");
 36659   DEFSYM (Qleft_to_right, "left-to-right");
 36660   defsubr (&Sbidi_resolved_levels);
 36661 
 36662 #ifdef HAVE_WINDOW_SYSTEM
 36663   DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p,
 36664     doc: /* Non-nil means draw block cursor as wide as the glyph under it.
 36665 For example, if a block cursor is over a tab, it will be drawn as
 36666 wide as that tab on the display.  */);
 36667   x_stretch_cursor_p = 0;
 36668 #endif
 36669 
 36670   DEFVAR_LISP ("show-trailing-whitespace", Vshow_trailing_whitespace,
 36671     doc: /* Non-nil means highlight trailing whitespace.
 36672 The face used for trailing whitespace is `trailing-whitespace'.  */);
 36673   Vshow_trailing_whitespace = Qnil;
 36674 
 36675   DEFVAR_LISP ("mode-line-compact", Vmode_line_compact,
 36676     doc: /* Non-nil means that mode lines should be compact.
 36677 This means that repeating spaces will be replaced with a single space.
 36678 If this variable is `long', only mode lines that are wider than the
 36679 currently selected window are compressed. */);
 36680   Vmode_line_compact = Qnil;
 36681   DEFSYM (Qlong, "long");
 36682 
 36683   DEFVAR_LISP ("nobreak-char-display", Vnobreak_char_display,
 36684     doc: /* Control highlighting of non-ASCII space and hyphen chars.
 36685 If the value is t, Emacs highlights non-ASCII chars which have the
 36686 same appearance as an ASCII space or hyphen, using the `nobreak-space'
 36687 or `nobreak-hyphen' face respectively.
 36688 
 36689 All of the non-ASCII characters in the Unicode horizontal whitespace
 36690 character class, as well as U+00AD (soft hyphen), U+2010 (hyphen), and
 36691 U+2011 (non-breaking hyphen) are affected.
 36692 
 36693 Any other non-nil value means to display these characters as an escape
 36694 glyph followed by an ordinary space or hyphen.
 36695 
 36696 A value of nil means no special handling of these characters.  */);
 36697   Vnobreak_char_display = Qt;
 36698 
 36699   DEFVAR_BOOL ("nobreak-char-ascii-display", nobreak_char_ascii_display,
 36700     doc: /* Control display of non-ASCII space and hyphen chars.
 36701 If the value of this variable is nil, the default, Emacs displays
 36702 non-ASCII chars which have the same appearance as an ASCII space
 36703 or hyphen as themselves, with the `nobreak-space' or `nobreak-hyphen'
 36704 face, respectively.
 36705 
 36706 If the value is t, these characters are displayed as their ASCII
 36707 counterparts: whitespace characters as ASCII space, hyphen characters
 36708 as ASCII hyphen (a.k.a. \"dash\"), using the `nobreak-space' or
 36709 the `nobreak-hyphen' face.
 36710 
 36711 This variable has effect only if `nobreak-char-display' is t;
 36712 otherwise it is ignored.
 36713 
 36714 All of the non-ASCII characters in the Unicode horizontal whitespace
 36715 character class, as well as U+00AD (soft hyphen), U+2010 (hyphen), and
 36716 U+2011 (non-breaking hyphen) are affected.  */);
 36717   nobreak_char_ascii_display = false;
 36718 
 36719   DEFVAR_LISP ("void-text-area-pointer", Vvoid_text_area_pointer,
 36720     doc: /* The pointer shape to show in void text areas.
 36721 A value of nil means to show the text pointer.  Other options are
 36722 `arrow', `text', `hand', `vdrag', `hdrag', `nhdrag', `modeline', and
 36723 `hourglass'.  */);
 36724   Vvoid_text_area_pointer = Qarrow;
 36725 
 36726   DEFVAR_LISP ("inhibit-redisplay", Vinhibit_redisplay,
 36727     doc: /* Non-nil means don't actually do any redisplay.
 36728 This is used for internal purposes.  */);
 36729   Vinhibit_redisplay = Qnil;
 36730 
 36731   DEFVAR_LISP ("global-mode-string", Vglobal_mode_string,
 36732     doc: /* String (or mode line construct) included (normally) in `mode-line-misc-info'.  */);
 36733   Vglobal_mode_string = Qnil;
 36734 
 36735   DEFVAR_LISP ("overlay-arrow-position", Voverlay_arrow_position,
 36736     doc: /* Marker for where to display an arrow on top of the buffer text.
 36737 This must be the beginning of a line in order to work.
 36738 See also `overlay-arrow-string'.  */);
 36739   Voverlay_arrow_position = Qnil;
 36740 
 36741   DEFVAR_LISP ("overlay-arrow-string", Voverlay_arrow_string,
 36742     doc: /* String to display as an arrow in non-window frames.
 36743 See also `overlay-arrow-position'.  */);
 36744   Voverlay_arrow_string = build_pure_c_string ("=>");
 36745 
 36746   DEFVAR_LISP ("overlay-arrow-variable-list", Voverlay_arrow_variable_list,
 36747     doc: /* List of variables (symbols) which hold markers for overlay arrows.
 36748 The symbols on this list are examined during redisplay to determine
 36749 where to display overlay arrows.  */);
 36750   Voverlay_arrow_variable_list
 36751     = list1 (intern_c_string ("overlay-arrow-position"));
 36752 
 36753   DEFVAR_INT ("scroll-step", emacs_scroll_step,
 36754     doc: /* The number of lines to try scrolling a window by when point moves out.
 36755 If that fails to bring point back on frame, point is centered instead.
 36756 If this is zero, point is always centered after it moves off frame.
 36757 If you want scrolling to always be a line at a time, you should set
 36758 `scroll-conservatively' to a large value rather than set this to 1.  */);
 36759 
 36760   DEFVAR_INT ("scroll-conservatively", scroll_conservatively,
 36761     doc: /* Scroll up to this many lines, to bring point back on screen.
 36762 If point moves off-screen, redisplay will scroll by up to
 36763 `scroll-conservatively' lines in order to bring point just barely
 36764 onto the screen again.  If that cannot be done, then redisplay
 36765 recenters point as usual.
 36766 
 36767 If the value is greater than 100, redisplay will never recenter point,
 36768 but will always scroll just enough text to bring point into view, even
 36769 if you move far away.
 36770 
 36771 A value of zero means always recenter point if it moves off screen.  */);
 36772   scroll_conservatively = 0;
 36773 
 36774   DEFVAR_INT ("scroll-margin", scroll_margin,
 36775     doc: /* Number of lines of margin at the top and bottom of a window.
 36776 Trigger automatic scrolling whenever point gets within this many lines
 36777 of the top or bottom of the window (see info node `Auto Scrolling').  */);
 36778   scroll_margin = 0;
 36779 
 36780   DEFVAR_LISP ("maximum-scroll-margin", Vmaximum_scroll_margin,
 36781     doc: /* Maximum effective value of `scroll-margin'.
 36782 Given as a fraction of the current window's lines.  The value should
 36783 be a floating point number between 0.0 and 0.5.  The effective maximum
 36784 is limited to (/ (1- window-lines) 2).  Non-float values for this
 36785 variable are ignored and the default 0.25 is used instead.  */);
 36786   Vmaximum_scroll_margin = make_float (0.25);
 36787 
 36788   DEFVAR_LISP ("display-pixels-per-inch",  Vdisplay_pixels_per_inch,
 36789     doc: /* Pixels per inch value for non-window system displays.
 36790 Value is a number or a cons (WIDTH-DPI . HEIGHT-DPI).  */);
 36791   Vdisplay_pixels_per_inch = make_float (72.0);
 36792 
 36793 #ifdef GLYPH_DEBUG
 36794   DEFVAR_INT ("debug-end-pos", debug_end_pos, doc: /* Don't ask.  */);
 36795 #endif
 36796 
 36797   DEFVAR_LISP ("truncate-partial-width-windows",
 36798                Vtruncate_partial_width_windows,
 36799     doc: /* Non-nil means truncate lines in windows narrower than the frame.
 36800 For an integer value, truncate lines in each window narrower than the
 36801 full frame width, provided the total window width in column units is less
 36802 than that integer; otherwise, respect the value of `truncate-lines'.
 36803 The total width of the window is as returned by `window-total-width', it
 36804 includes the fringes, the continuation and truncation glyphs, the
 36805 display margins (if any), and the scroll bar
 36806 
 36807 For any other non-nil value, truncate lines in all windows that do
 36808 not span the full frame width.
 36809 
 36810 A value of nil means to respect the value of `truncate-lines'.
 36811 
 36812 If `word-wrap' is enabled, you might want to reduce the value of this.
 36813 
 36814 Don't set this to a non-nil value when `visual-line-mode' is
 36815 turned on, as it could produce confusing results.  */);
 36816   Vtruncate_partial_width_windows = make_fixnum (50);
 36817 
 36818   DEFVAR_BOOL("word-wrap-by-category", word_wrap_by_category, doc: /*
 36819     Non-nil means also wrap after characters of a certain category.
 36820 Normally when `word-wrap' is on, Emacs only breaks lines after
 36821 whitespace characters.  When this option is turned on, Emacs also
 36822 breaks lines after characters that have the "|" category (defined in
 36823 characters.el).  This is useful for allowing breaking after CJK
 36824 characters and improves the word-wrapping for CJK text mixed with
 36825 Latin text.
 36826 
 36827 If this variable is set using Customize, Emacs automatically loads
 36828 kinsoku.el.  When kinsoku.el is loaded, Emacs respects kinsoku rules
 36829 when breaking lines.  That means characters with the ">" category
 36830 don't appear at the beginning of a line (e.g., FULLWIDTH COMMA), and
 36831 characters with the "<" category don't appear at the end of a line
 36832 (e.g., LEFT DOUBLE ANGLE BRACKET).  */);
 36833   word_wrap_by_category = false;
 36834 
 36835   DEFVAR_LISP ("line-number-display-limit", Vline_number_display_limit,
 36836     doc: /* Maximum buffer size for which line number should be displayed.
 36837 If the buffer is bigger than this, the line number does not appear
 36838 in the mode line.  A value of nil means no limit.  */);
 36839   Vline_number_display_limit = Qnil;
 36840 
 36841   DEFVAR_INT ("line-number-display-limit-width",
 36842               line_number_display_limit_width,
 36843     doc: /* Maximum line width (in characters) for line number display.
 36844 If the average length of the lines near point is bigger than this, then the
 36845 line number may be omitted from the mode line.  */);
 36846   line_number_display_limit_width = 200;
 36847 
 36848   DEFVAR_BOOL ("highlight-nonselected-windows", highlight_nonselected_windows,
 36849     doc: /* Non-nil means highlight active region even in nonselected windows.
 36850 When nil (the default), the active region is only highlighted when
 36851 the window is selected.  */);
 36852   highlight_nonselected_windows = false;
 36853 
 36854   DEFVAR_BOOL ("multiple-frames", multiple_frames,
 36855     doc: /* Non-nil if more than one frame is visible on this display.
 36856 Minibuffer-only frames don't count, but iconified frames do.
 36857 This variable is not guaranteed to be accurate except while processing
 36858 `frame-title-format' and `icon-title-format'.  */);
 36859 
 36860   DEFVAR_LISP ("frame-title-format", Vframe_title_format,
 36861     doc: /* Template for displaying the title bar of visible frames.
 36862 \(Assuming the window manager supports this feature.)
 36863 
 36864 This variable has the same structure as `mode-line-format', except that
 36865 the %c, %C, and %l constructs are ignored.  It is used only on frames for
 36866 which no explicit name has been set (see `modify-frame-parameters').  */);
 36867 
 36868   DEFVAR_LISP ("icon-title-format", Vicon_title_format,
 36869     doc: /* Template for displaying the title bar of an iconified frame.
 36870 \(Assuming the window manager supports this feature.)
 36871 If the value is a string, it should have the same structure
 36872 as `mode-line-format' (which see), and is used only on frames
 36873 for which no explicit name has been set \(see `modify-frame-parameters').
 36874 If the value is t, that means use `frame-title-format' for
 36875 iconified frames.  */);
 36876   /* Do not nest calls to pure_list.  This works around a bug in
 36877      Oracle Developer Studio 12.6.  */
 36878   Lisp_Object icon_title_name_format
 36879     = pure_list (empty_unibyte_string,
 36880                  build_pure_c_string ("%b - GNU Emacs at "),
 36881                  intern_c_string ("system-name"));
 36882   Vicon_title_format
 36883     = Vframe_title_format
 36884     = pure_list (intern_c_string ("multiple-frames"),
 36885                  build_pure_c_string ("%b"),
 36886                  icon_title_name_format);
 36887 
 36888   DEFVAR_LISP ("message-log-max", Vmessage_log_max,
 36889     doc: /* Maximum number of lines to keep in the message log buffer.
 36890 If nil, disable message logging.  If t, log messages but don't truncate
 36891 the buffer when it becomes large.  */);
 36892   Vmessage_log_max = make_fixnum (1000);
 36893 
 36894   DEFVAR_LISP ("window-scroll-functions", Vwindow_scroll_functions,
 36895     doc: /* List of functions to call before redisplaying a window with scrolling.
 36896 Each function is called with two arguments, the window and its new
 36897 display-start position.
 36898 These functions are called whenever the `window-start' marker is modified,
 36899 either to point into another buffer (e.g. via `set-window-buffer') or another
 36900 place in the same buffer.
 36901 When each function is called, the `window-start' marker of its window
 36902 argument has been already set to the new value, and the buffer which that
 36903 window will display is set to be the current buffer.
 36904 Note that the value of `window-end' is not valid when these functions are
 36905 called.
 36906 
 36907 Warning: Do not use this feature to alter the way the window
 36908 is scrolled.  It is not designed for that, and such use probably won't
 36909 work.  */);
 36910   Vwindow_scroll_functions = Qnil;
 36911 
 36912   DEFVAR_LISP ("mouse-autoselect-window", Vmouse_autoselect_window,
 36913      doc: /* Non-nil means autoselect window with mouse pointer.
 36914 If nil, do not autoselect windows.
 36915 A positive number means delay autoselection by that many seconds: a
 36916 window is autoselected only after the mouse has remained in that
 36917 window for the duration of the delay.
 36918 A negative number has a similar effect, but causes windows to be
 36919 autoselected only after the mouse has stopped moving.  (Because of
 36920 the way Emacs compares mouse events, you will occasionally wait twice
 36921 that time before the window gets selected.)
 36922 Any other value means to autoselect window instantaneously when the
 36923 mouse pointer enters it.
 36924 
 36925 Autoselection selects the minibuffer only if it is active, and never
 36926 unselects the minibuffer if it is active.
 36927 
 36928 If you want to use the mouse to autoselect a window on another frame,
 36929 make sure that (1) your window manager has focus follow the mouse and
 36930 (2) the value of the option `focus-follows-mouse' matches the policy
 36931 of your window manager.  */);
 36932   Vmouse_autoselect_window = Qnil;
 36933 
 36934   DEFVAR_LISP ("auto-resize-tab-bars", Vauto_resize_tab_bars,
 36935     doc: /* Non-nil means automatically resize tab-bars.
 36936 This dynamically changes the tab-bar's height to the minimum height
 36937 that is needed to make all tab-bar items visible.
 36938 If value is `grow-only', the tab-bar's height is only increased
 36939 automatically; to decrease the tab-bar height, use \\[recenter],
 36940 after setting `recenter-redisplay' to the value of t.  */);
 36941   Vauto_resize_tab_bars = Qt;
 36942 
 36943   DEFVAR_BOOL ("auto-raise-tab-bar-buttons", auto_raise_tab_bar_buttons_p,
 36944     doc: /* Non-nil means raise tab-bar buttons when the mouse moves over them.  */);
 36945   auto_raise_tab_bar_buttons_p = true;
 36946 
 36947   DEFVAR_LISP ("auto-resize-tool-bars", Vauto_resize_tool_bars,
 36948     doc: /* Non-nil means automatically resize tool-bars.
 36949 This dynamically changes the tool-bar's height to the minimum height
 36950 that is needed to make all tool-bar items visible.
 36951 If value is `grow-only', the tool-bar's height is only increased
 36952 automatically; to decrease the tool-bar height, use \\[recenter],
 36953 after setting `recenter-redisplay' to the value of t.  */);
 36954   Vauto_resize_tool_bars = Qt;
 36955 
 36956   DEFVAR_BOOL ("auto-raise-tool-bar-buttons", auto_raise_tool_bar_buttons_p,
 36957     doc: /* Non-nil means raise tool-bar buttons when the mouse moves over them.  */);
 36958   auto_raise_tool_bar_buttons_p = true;
 36959 
 36960   DEFVAR_LISP ("make-cursor-line-fully-visible", Vmake_cursor_line_fully_visible,
 36961     doc: /* Whether to scroll the window if the cursor line is not fully visible.
 36962 If the value is non-nil, Emacs scrolls or recenters the window to make
 36963 the cursor line fully visible.  The value could also be a function, which
 36964 is called with a single argument, the window to be scrolled, and should
 36965 return non-nil if the partially-visible cursor requires scrolling the
 36966 window, nil if it's okay to leave the cursor partially-visible.  */);
 36967   Vmake_cursor_line_fully_visible = Qt;
 36968   DEFSYM (Qmake_cursor_line_fully_visible, "make-cursor-line-fully-visible");
 36969 
 36970   DEFVAR_BOOL ("make-window-start-visible", make_window_start_visible,
 36971     doc: /* Whether to ensure `window-start' position is never invisible.  */);
 36972   make_window_start_visible = false;
 36973   DEFSYM (Qmake_window_start_visible, "make-window-start-visible");
 36974   Fmake_variable_buffer_local (Qmake_window_start_visible);
 36975 
 36976   DEFSYM (Qclose_tab, "close-tab");
 36977   DEFVAR_LISP ("tab-bar-border", Vtab_bar_border,
 36978     doc: /* Border below tab-bar in pixels.
 36979 If an integer, use it as the height of the border.
 36980 If it is one of `internal-border-width' or `border-width', use the
 36981 value of the corresponding frame parameter.
 36982 Otherwise, no border is added below the tab-bar.  */);
 36983   Vtab_bar_border = Qinternal_border_width;
 36984 
 36985   DEFVAR_LISP ("tab-bar-button-margin", Vtab_bar_button_margin,
 36986     doc: /* Margin around tab-bar buttons in pixels.
 36987 If an integer, use that for both horizontal and vertical margins.
 36988 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
 36989 HORZ specifying the horizontal margin, and VERT specifying the
 36990 vertical margin.  */);
 36991   Vtab_bar_button_margin = make_fixnum (DEFAULT_TAB_BAR_BUTTON_MARGIN);
 36992 
 36993   DEFVAR_INT ("tab-bar-button-relief", tab_bar_button_relief,
 36994     doc: /* Relief thickness of tab-bar buttons.  */);
 36995   tab_bar_button_relief = DEFAULT_TAB_BAR_BUTTON_RELIEF;
 36996 
 36997   DEFVAR_LISP ("tool-bar-border", Vtool_bar_border,
 36998     doc: /* Border below tool-bar in pixels.
 36999 If an integer, use it as the height of the border.
 37000 If it is one of `internal-border-width' or `border-width', use the
 37001 value of the corresponding frame parameter.
 37002 Otherwise, no border is added below the tool-bar.  */);
 37003   Vtool_bar_border = Qinternal_border_width;
 37004 
 37005   DEFVAR_LISP ("tool-bar-button-margin", Vtool_bar_button_margin,
 37006     doc: /* Margin around tool-bar buttons in pixels.
 37007 If an integer, use that for both horizontal and vertical margins.
 37008 Otherwise, value should be a pair of integers `(HORZ . VERT)' with
 37009 HORZ specifying the horizontal margin, and VERT specifying the
 37010 vertical margin.  */);
 37011   Vtool_bar_button_margin = make_fixnum (DEFAULT_TOOL_BAR_BUTTON_MARGIN);
 37012 
 37013   DEFVAR_INT ("tool-bar-button-relief", tool_bar_button_relief,
 37014     doc: /* Relief thickness of tool-bar buttons.  */);
 37015   tool_bar_button_relief = DEFAULT_TOOL_BAR_BUTTON_RELIEF;
 37016 
 37017   DEFVAR_LISP ("tool-bar-style", Vtool_bar_style,
 37018     doc: /* Tool bar style to use.
 37019 It can be one of
 37020  image            - show images only
 37021  text             - show text only
 37022  both             - show both, text below image
 37023  both-horiz       - show text to the right of the image
 37024  text-image-horiz - show text to the left of the image
 37025  any other        - use system default or image if no system default.
 37026 
 37027 This variable only affects the GTK+ toolkit version of Emacs.  */);
 37028   Vtool_bar_style = Qnil;
 37029 
 37030   DEFVAR_INT ("tool-bar-max-label-size", tool_bar_max_label_size,
 37031     doc: /* Maximum number of characters a label can have to be shown.
 37032 The tool bar style must also show labels for this to have any effect, see
 37033 `tool-bar-style'.  */);
 37034   tool_bar_max_label_size = DEFAULT_TOOL_BAR_LABEL_SIZE;
 37035 
 37036   DEFVAR_LISP ("fontification-functions", Vfontification_functions,
 37037     doc: /* List of functions to call to fontify regions of text.
 37038 Each function is called with one argument POS.  Functions must
 37039 fontify a region starting at POS in the current buffer, and give
 37040 fontified regions the property `fontified' with a non-nil value.
 37041 
 37042 Note that, when `long-line-optimizations-p' is non-nil in the buffer,
 37043 these functions are called as if they were in a `with-restriction' form,
 37044 with a `long-line-optimizations-in-fontification-functions' label and
 37045 with the buffer narrowed to a portion around POS whose size is
 37046 specified by `long-line-optimizations-region-size'.  */);
 37047   Vfontification_functions = Qnil;
 37048   Fmake_variable_buffer_local (Qfontification_functions);
 37049 
 37050   DEFVAR_BOOL ("unibyte-display-via-language-environment",
 37051                unibyte_display_via_language_environment,
 37052     doc: /* Non-nil means display unibyte text according to language environment.
 37053 Specifically, this means that raw bytes in the range 160-255 decimal
 37054 are displayed by converting them to the equivalent multibyte characters
 37055 according to the current language environment.  As a result, they are
 37056 displayed according to the current fontset.
 37057 
 37058 Note that this variable affects only how these bytes are displayed,
 37059 but does not change the fact they are interpreted as raw bytes.  */);
 37060   unibyte_display_via_language_environment = false;
 37061 
 37062   DEFVAR_LISP ("max-mini-window-height", Vmax_mini_window_height,
 37063     doc: /* Maximum height for resizing mini-windows (the minibuffer and the echo area).
 37064 If a float, it specifies the maximum height in units of the
 37065 mini-window frame's height.
 37066 If an integer, it specifies the maximum height in units of the
 37067 mini-window frame's default font's height.  */);
 37068   Vmax_mini_window_height = make_float (0.25);
 37069 
 37070   DEFVAR_LISP ("resize-mini-windows", Vresize_mini_windows,
 37071     doc: /* How to resize mini-windows (the minibuffer and the echo area).
 37072 A value of nil means don't automatically resize mini-windows.
 37073 A value of t means resize them to fit the text displayed in them.
 37074 A value of `grow-only', the default, means let mini-windows grow only;
 37075 they return to their normal size when the minibuffer is closed, or the
 37076 echo area becomes empty.
 37077 
 37078 This variable does not affect resizing of the minibuffer window of
 37079 minibuffer-only frames.  These are handled by `resize-mini-frames'
 37080 only.  */);
 37081   /* Contrary to the doc string, we initialize this to nil, so that
 37082      loading loadup.el won't try to resize windows before loading
 37083      window.el, where some functions we need to call for this live.
 37084      We assign the 'grow-only' value right after loading window.el
 37085      during loadup.  */
 37086   Vresize_mini_windows = Qnil;
 37087 
 37088   DEFVAR_LISP ("blink-cursor-alist", Vblink_cursor_alist,
 37089     doc: /* Alist specifying how to blink the cursor off.
 37090 Each element has the form (ON-STATE . OFF-STATE).  Whenever the
 37091 `cursor-type' frame-parameter or variable equals ON-STATE,
 37092 comparing using `equal', Emacs uses OFF-STATE to specify
 37093 how to blink it off.  ON-STATE and OFF-STATE are values for
 37094 the `cursor-type' frame parameter.
 37095 
 37096 If a frame's ON-STATE has no entry in this list,
 37097 the frame's other specifications determine how to blink the cursor off.  */);
 37098   Vblink_cursor_alist = Qnil;
 37099 
 37100   DEFVAR_LISP ("auto-hscroll-mode", automatic_hscrolling,
 37101     doc: /* Allow or disallow automatic horizontal scrolling of windows.
 37102 The value `current-line' means the line displaying point in each window
 37103 is automatically scrolled horizontally to make point visible.
 37104 Any other non-nil value means all the lines in a window are automatically
 37105 scrolled horizontally to make point visible.  */);
 37106   automatic_hscrolling = Qt;
 37107   DEFSYM (Qauto_hscroll_mode, "auto-hscroll-mode");
 37108   DEFSYM (Qcurrent_line, "current-line");
 37109 
 37110   DEFVAR_INT ("hscroll-margin", hscroll_margin,
 37111     doc: /* How many columns away from the window edge point is allowed to get
 37112 before automatic hscrolling will horizontally scroll the window.  */);
 37113   hscroll_margin = 5;
 37114 
 37115   DEFVAR_LISP ("hscroll-step", Vhscroll_step,
 37116     doc: /* How many columns to scroll the window when point gets too close to the edge.
 37117 When point is less than `hscroll-margin' columns from the window
 37118 edge, automatic hscrolling will scroll the window by the amount of columns
 37119 determined by this variable.  If its value is a positive integer, scroll that
 37120 many columns.  If it's a positive floating-point number, it specifies the
 37121 fraction of the window's width to scroll.  If it's nil or zero, point will be
 37122 centered horizontally after the scroll.  Any other value, including negative
 37123 numbers, are treated as if the value were zero.
 37124 
 37125 Automatic hscrolling always moves point outside the scroll margin, so if
 37126 point was more than scroll step columns inside the margin, the window will
 37127 scroll more than the value given by the scroll step.
 37128 
 37129 Note that the lower bound for automatic hscrolling specified by `scroll-left'
 37130 and `scroll-right' overrides this variable's effect.  */);
 37131   Vhscroll_step = make_fixnum (0);
 37132 
 37133   DEFVAR_BOOL ("message-truncate-lines", message_truncate_lines,
 37134     doc: /* If non-nil, messages are truncated when displaying the echo area.
 37135 Bind this around calls to `message' to let it take effect.  */);
 37136   message_truncate_lines = false;
 37137 
 37138   DEFVAR_LISP ("menu-bar-update-hook",  Vmenu_bar_update_hook,
 37139     doc: /* Normal hook run to update the menu bar definitions.
 37140 Redisplay runs this hook before it redisplays the menu bar.
 37141 This is used to update menus such as Buffers, whose contents depend on
 37142 various data.  */);
 37143   Vmenu_bar_update_hook = Qnil;
 37144 
 37145   DEFVAR_LISP ("menu-updating-frame", Vmenu_updating_frame,
 37146                doc: /* Frame for which we are updating a menu.
 37147 The enable predicate for a menu binding should check this variable.  */);
 37148   Vmenu_updating_frame = Qnil;
 37149 
 37150   DEFVAR_BOOL ("inhibit-menubar-update", inhibit_menubar_update,
 37151     doc: /* Non-nil means don't update menu bars.  Internal use only.  */);
 37152   inhibit_menubar_update = false;
 37153 
 37154   DEFVAR_LISP ("wrap-prefix", Vwrap_prefix,
 37155     doc: /* Prefix prepended to all continuation lines at display time.
 37156 The value may be a string, an image, or a stretch-glyph; it is
 37157 interpreted in the same way as the value of a `display' text property.
 37158 
 37159 This variable is overridden by any `wrap-prefix' text or overlay
 37160 property.
 37161 
 37162 To add a prefix to non-continuation lines, use `line-prefix'.  */);
 37163   Vwrap_prefix = Qnil;
 37164   DEFSYM (Qwrap_prefix, "wrap-prefix");
 37165   Fmake_variable_buffer_local (Qwrap_prefix);
 37166 
 37167   DEFVAR_LISP ("line-prefix", Vline_prefix,
 37168     doc: /* Prefix prepended to all non-continuation lines at display time.
 37169 The value may be a string, an image, or a stretch-glyph; it is
 37170 interpreted in the same way as the value of a `display' text property.
 37171 
 37172 This variable is overridden by any `line-prefix' text or overlay
 37173 property.
 37174 
 37175 To add a prefix to continuation lines, use `wrap-prefix'.  */);
 37176   Vline_prefix = Qnil;
 37177   DEFSYM (Qline_prefix, "line-prefix");
 37178   Fmake_variable_buffer_local (Qline_prefix);
 37179 
 37180   DEFVAR_LISP ("display-line-numbers", Vdisplay_line_numbers,
 37181     doc: /* Non-nil means display line numbers.
 37182 
 37183 If the value is t, display the absolute number of each line of a buffer
 37184 shown in a window.  Absolute line numbers count from the beginning of
 37185 the current narrowing, or from buffer beginning.  The variable
 37186 `display-line-numbers-offset', if non-zero, is a signed offset added
 37187 to each absolute line number; it also forces line numbers to be counted
 37188 from the beginning of the buffer, as if `display-line-numbers-widen'
 37189 were non-nil.  It has no effect when line numbers are not absolute.
 37190 
 37191 If the value is `relative', display for each line not containing the
 37192 window's point its relative number instead, i.e. the number of the line
 37193 relative to the line showing the window's point.
 37194 
 37195 In either case, line numbers are displayed at the beginning of each
 37196 non-continuation line that displays buffer text, i.e. after each newline
 37197 character that comes from the buffer.  The value `visual' is like
 37198 `relative' but counts screen lines instead of buffer lines.  In practice
 37199 this means that continuation lines count as well when calculating the
 37200 relative number of a line.
 37201 
 37202 Lisp programs can disable display of a line number of a particular
 37203 buffer line by putting the `display-line-numbers-disable' text property
 37204 or overlay property on the first visible character of that line.  */);
 37205   Vdisplay_line_numbers = Qnil;
 37206   DEFSYM (Qdisplay_line_numbers, "display-line-numbers");
 37207   Fmake_variable_buffer_local (Qdisplay_line_numbers);
 37208   DEFSYM (Qrelative, "relative");
 37209   DEFSYM (Qvisual, "visual");
 37210 
 37211   DEFVAR_LISP ("display-line-numbers-width", Vdisplay_line_numbers_width,
 37212     doc: /* Minimum width of space reserved for line number display.
 37213 A positive number means reserve that many columns for line numbers,
 37214 even if the actual number needs less space.
 37215 The default value of nil means compute the space dynamically.
 37216 Any other value is treated as nil.  */);
 37217   Vdisplay_line_numbers_width = Qnil;
 37218   DEFSYM (Qdisplay_line_numbers_width, "display-line-numbers-width");
 37219   Fmake_variable_buffer_local (Qdisplay_line_numbers_width);
 37220 
 37221   DEFVAR_LISP ("display-line-numbers-current-absolute",
 37222                Vdisplay_line_numbers_current_absolute,
 37223     doc: /* Non-nil means display absolute number of current line.
 37224 This variable has effect only when `display-line-numbers' is
 37225 either `relative' or `visual'.  */);
 37226   Vdisplay_line_numbers_current_absolute = Qt;
 37227 
 37228   DEFVAR_BOOL ("display-line-numbers-widen", display_line_numbers_widen,
 37229     doc: /* Non-nil means display line numbers disregarding any narrowing.  */);
 37230   display_line_numbers_widen = false;
 37231   DEFSYM (Qdisplay_line_numbers_widen, "display-line-numbers-widen");
 37232   Fmake_variable_buffer_local (Qdisplay_line_numbers_widen);
 37233 
 37234   DEFVAR_INT ("display-line-numbers-offset", display_line_numbers_offset,
 37235     doc: /* A signed integer added to each absolute line number.
 37236 When this variable is non-zero, line numbers are always counted from
 37237 the beginning of the buffer even if `display-line-numbers-widen' is nil.
 37238 It has no effect when set to 0, or when line numbers are not absolute.  */);
 37239   display_line_numbers_offset = 0;
 37240   DEFSYM (Qdisplay_line_numbers_offset, "display-line-numbers-offset");
 37241   Fmake_variable_buffer_local (Qdisplay_line_numbers_offset);
 37242 
 37243   DEFVAR_BOOL ("display-fill-column-indicator", display_fill_column_indicator,
 37244     doc: /* Non-nil means display the fill column indicator.
 37245 If you set this non-nil, make sure `display-fill-column-indicator-character'
 37246 is also non-nil.
 37247 See Info node `Displaying Boundaries' for details.  */);
 37248   display_fill_column_indicator = false;
 37249   DEFSYM (Qdisplay_fill_column_indicator, "display-fill-column-indicator");
 37250   Fmake_variable_buffer_local (Qdisplay_fill_column_indicator);
 37251 
 37252   DEFVAR_LISP ("display-fill-column-indicator-column", Vdisplay_fill_column_indicator_column,
 37253     doc: /* Column for indicator when `display-fill-column-indicator' is non-nil.
 37254 The default value is t which means that the indicator
 37255 will use the `fill-column' variable.  If it is set to an integer the
 37256 indicator will be drawn in that column.
 37257 See Info node `Displaying Boundaries' for details.  */);
 37258   Vdisplay_fill_column_indicator_column = Qt;
 37259   DEFSYM (Qdisplay_fill_column_indicator_column, "display-fill-column-indicator-column");
 37260   Fmake_variable_buffer_local (Qdisplay_fill_column_indicator_column);
 37261 
 37262   DEFVAR_LISP ("display-fill-column-indicator-character", Vdisplay_fill_column_indicator_character,
 37263     doc: /* Character to draw the indicator when `display-fill-column-indicator' is non-nil.
 37264 A good candidate is U+2502, and an alternative is (ascii 124) if the
 37265 font of `fill-column-indicator' face does not support Unicode characters.
 37266 See Info node `Displaying Boundaries' for details.  */);
 37267   Vdisplay_fill_column_indicator_character = Qnil;
 37268   DEFSYM (Qdisplay_fill_column_indicator_character, "display-fill-column-indicator-character");
 37269   Fmake_variable_buffer_local (Qdisplay_fill_column_indicator_character);
 37270 
 37271   DEFVAR_INT ("display-line-numbers-major-tick", display_line_numbers_major_tick,
 37272     doc: /* If an integer N > 0, highlight line number of every Nth line.
 37273 The line number is shown with the `line-number-major-tick' face.
 37274 Otherwise, no special highlighting is done every Nth line.
 37275 Note that major ticks take precedence over minor ticks.  */);
 37276   display_line_numbers_major_tick = 0;
 37277 
 37278   DEFVAR_INT ("display-line-numbers-minor-tick", display_line_numbers_minor_tick,
 37279     doc: /* If an integer N > 0, highlight line number of every Nth line.
 37280 The line number is shown with the `line-number-minor-tick' face.
 37281 Otherwise, no special highlighting is done every Nth line.
 37282 Note that major ticks take precedence over minor ticks.  */);
 37283   display_line_numbers_minor_tick = 0;
 37284 
 37285   DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay,
 37286     doc: /* Non-nil means don't eval Lisp during redisplay.  */);
 37287   inhibit_eval_during_redisplay = false;
 37288 
 37289   DEFVAR_BOOL ("inhibit-free-realized-faces", inhibit_free_realized_faces,
 37290     doc: /* Non-nil means don't free realized faces.  Internal use only.  */);
 37291   inhibit_free_realized_faces = false;
 37292 
 37293   DEFVAR_BOOL ("inhibit-bidi-mirroring", inhibit_bidi_mirroring,
 37294     doc: /* Non-nil means don't mirror characters even when bidi context requires that.
 37295 Intended for use during debugging and for testing bidi display;
 37296 see biditest.el in the test suite.  */);
 37297   inhibit_bidi_mirroring = false;
 37298 
 37299   DEFVAR_BOOL ("bidi-inhibit-bpa", bidi_inhibit_bpa,
 37300     doc: /* Non-nil means inhibit the Bidirectional Parentheses Algorithm.
 37301 Disabling the BPA makes redisplay faster, but might produce incorrect
 37302 display reordering of bidirectional text with embedded parentheses and
 37303 other bracket characters whose `paired-bracket' Unicode property is
 37304 non-nil, see `get-char-code-property'.  */);
 37305   bidi_inhibit_bpa = false;
 37306 
 37307 #ifdef GLYPH_DEBUG
 37308   DEFVAR_BOOL ("inhibit-try-window-id", inhibit_try_window_id,
 37309                doc: /* Inhibit try_window_id display optimization.  */);
 37310   inhibit_try_window_id = false;
 37311 
 37312   DEFVAR_BOOL ("inhibit-try-window-reusing", inhibit_try_window_reusing,
 37313                doc: /* Inhibit try_window_reusing display optimization.  */);
 37314   inhibit_try_window_reusing = false;
 37315 
 37316   DEFVAR_BOOL ("inhibit-try-cursor-movement", inhibit_try_cursor_movement,
 37317                doc: /* Inhibit try_cursor_movement display optimization.  */);
 37318   inhibit_try_cursor_movement = false;
 37319 #endif /* GLYPH_DEBUG */
 37320 
 37321   DEFVAR_INT ("overline-margin", overline_margin,
 37322                doc: /* Space between overline and text, in pixels.
 37323 The default value is 2: the height of the overline (1 pixel) plus 1 pixel
 37324 margin to the character height.  */);
 37325   overline_margin = 2;
 37326 
 37327   DEFVAR_INT ("underline-minimum-offset",
 37328                underline_minimum_offset,
 37329      doc: /* Minimum distance between baseline and underline.
 37330 This can improve legibility of underlined text at small font sizes,
 37331 particularly when using variable `x-use-underline-position-properties'
 37332 with fonts that specify an UNDERLINE_POSITION relatively close to the
 37333 baseline.  The default value is 1.  */);
 37334   underline_minimum_offset = 1;
 37335   DEFSYM (Qunderline_minimum_offset, "underline-minimum-offset");
 37336 
 37337   DEFVAR_BOOL ("display-hourglass", display_hourglass_p,
 37338                doc: /* Non-nil means show an hourglass pointer, when Emacs is busy.
 37339 This feature only works when on a window system that can change
 37340 cursor shapes.  */);
 37341   display_hourglass_p = true;
 37342 
 37343   DEFVAR_LISP ("hourglass-delay", Vhourglass_delay,
 37344                doc: /* Seconds to wait before displaying an hourglass pointer when Emacs is busy.  */);
 37345   Vhourglass_delay = make_fixnum (DEFAULT_HOURGLASS_DELAY);
 37346 
 37347 #ifdef HAVE_WINDOW_SYSTEM
 37348   hourglass_atimer = NULL;
 37349   hourglass_shown_p = false;
 37350 #endif /* HAVE_WINDOW_SYSTEM */
 37351 
 37352   /* Name of the face used to display glyphless characters.  */
 37353   DEFSYM (Qglyphless_char, "glyphless-char");
 37354 
 37355   /* Method symbols for Vglyphless_char_display.  */
 37356   DEFSYM (Qhex_code, "hex-code");
 37357   DEFSYM (Qempty_box, "empty-box");
 37358   DEFSYM (Qthin_space, "thin-space");
 37359   DEFSYM (Qzero_width, "zero-width");
 37360 
 37361   DEFVAR_LISP ("pre-redisplay-function", Vpre_redisplay_function,
 37362                doc: /* Function run just before redisplay.
 37363 It is called with one argument, which is the set of windows that are to
 37364 be redisplayed.  This set can be nil (meaning, only the selected window),
 37365 or t (meaning all windows).  */);
 37366   Vpre_redisplay_function = intern ("ignore");
 37367 
 37368   /* Symbol for the purpose of Vglyphless_char_display.  */
 37369   DEFSYM (Qglyphless_char_display, "glyphless-char-display");
 37370   Fput (Qglyphless_char_display, Qchar_table_extra_slots, make_fixnum (1));
 37371 
 37372   DEFVAR_LISP ("glyphless-char-display", Vglyphless_char_display,
 37373                doc: /* Char-table defining glyphless characters.
 37374 Each element, if non-nil, should be one of the following:
 37375   an ASCII acronym string: display this string in a box
 37376   `hex-code':   display the hexadecimal code of a character in a box
 37377   `empty-box':  display as an empty box
 37378   `thin-space': display as 1-pixel width space
 37379   `zero-width': don't display
 37380 Any other value is interpreted as `empty-box'.
 37381 An element may also be a cons cell (GRAPHICAL . TEXT), which specifies the
 37382 display method for graphical terminals and text terminals respectively.
 37383 GRAPHICAL and TEXT should each have one of the values listed above.
 37384 
 37385 The char-table has one extra slot to control the display of characters
 37386 for which no font is found on graphical terminals, and characters that
 37387 cannot be displayed by text-mode terminals.  Its value should be an
 37388 ASCII acronym string, `hex-code', `empty-box', or `thin-space'.  It
 37389 could also be a cons cell of any two of these, to specify separate
 37390 values for graphical and text terminals.  The default is `empty-box'.
 37391 
 37392 With the obvious exception of `zero-width', all the other representations
 37393 are displayed using the face `glyphless-char'.
 37394 
 37395 If a character has a non-nil entry in an active display table, the
 37396 display table takes effect; in this case, Emacs does not consult
 37397 `glyphless-char-display' at all.  */);
 37398   Vglyphless_char_display = Fmake_char_table (Qglyphless_char_display, Qnil);
 37399   Fset_char_table_extra_slot (Vglyphless_char_display, make_fixnum (0),
 37400                               Qempty_box);
 37401 
 37402   DEFVAR_LISP ("debug-on-message", Vdebug_on_message,
 37403                doc: /* If non-nil, debug if a message matching this regexp is displayed.  */);
 37404   Vdebug_on_message = Qnil;
 37405 
 37406   DEFVAR_LISP ("set-message-function", Vset_message_function,
 37407                doc: /* If non-nil, function to handle display of echo-area messages.
 37408 The function is called with one argument that is the text of a message.
 37409 If this function returns nil, the message is displayed in the echo area
 37410 as usual.  If the function returns a string, the returned string is
 37411 displayed in the echo area.  If this function returns any other non-nil
 37412 value, this means that the message was already handled, and the original
 37413 message text will not be displayed in the echo area.
 37414 
 37415 Also see `clear-message-function' (which can be used to clear the
 37416 message displayed by this function), and `command-error-function'
 37417 (which controls how error messages are displayed).  */);
 37418   Vset_message_function = Qnil;
 37419 
 37420   DEFSYM (Qdont_clear_message, "dont-clear-message");
 37421   DEFVAR_LISP ("clear-message-function", Vclear_message_function,
 37422                doc: /* If non-nil, function to clear echo-area messages.
 37423 Usually this function is called when the next input event arrives.
 37424 It is expected to clear the message displayed by its counterpart
 37425 function specified by `set-message-function'.
 37426 
 37427 The function is called without arguments.
 37428 
 37429 If this function returns a value that isn't `dont-clear-message', the
 37430 message is cleared from the echo area as usual.  If this function
 37431 returns `dont-clear-message', this means that the message was already
 37432 handled, and the original message text will not be cleared from the
 37433 echo area.  */);
 37434   Vclear_message_function = Qnil;
 37435 
 37436   DEFVAR_LISP ("redisplay--all-windows-cause", Vredisplay__all_windows_cause,
 37437                doc: /* Code of the cause for redisplaying all windows.
 37438 Internal use only.  */);
 37439   Vredisplay__all_windows_cause = Fmake_hash_table (0, NULL);
 37440 
 37441   DEFVAR_LISP ("redisplay--mode-lines-cause", Vredisplay__mode_lines_cause,
 37442                doc: /* Code of the cause for redisplaying mode lines.
 37443 Internal use only.  */);
 37444   Vredisplay__mode_lines_cause = Fmake_hash_table (0, NULL);
 37445 
 37446   DEFVAR_BOOL ("redisplay--inhibit-bidi", redisplay__inhibit_bidi,
 37447      doc: /* Non-nil means it is not safe to attempt bidi reordering for display.  */);
 37448   /* Initialize to t, since we need to disable reordering until
 37449      loadup.el successfully loads charprop.el.  */
 37450   redisplay__inhibit_bidi = true;
 37451 
 37452   DEFVAR_BOOL ("display-raw-bytes-as-hex", display_raw_bytes_as_hex,
 37453     doc: /* Non-nil means display raw bytes in hexadecimal format.
 37454 The default is to use octal format (\\200) whereas hexadecimal (\\x80)
 37455 may be more familiar to users.  */);
 37456   display_raw_bytes_as_hex = false;
 37457 
 37458   DEFVAR_BOOL ("mouse-fine-grained-tracking", mouse_fine_grained_tracking,
 37459     doc: /* Non-nil for pixel-wise mouse-movement.
 37460 When nil, mouse-movement events will not be generated as long as the
 37461 mouse stays within the extent of a single glyph (except for images).  */);
 37462   mouse_fine_grained_tracking = false;
 37463 
 37464   DEFVAR_BOOL ("tab-bar--dragging-in-progress", tab_bar__dragging_in_progress,
 37465     doc: /* Non-nil when maybe dragging tab bar item.  */);
 37466   tab_bar__dragging_in_progress = false;
 37467 
 37468   DEFVAR_BOOL ("redisplay-skip-initial-frame", redisplay_skip_initial_frame,
 37469     doc: /* Non-nil means skip redisplay of the initial frame.
 37470 The initial frame is the text-mode frame used by Emacs internally during
 37471 the early stages of startup.  That frame is not displayed anywhere, so
 37472 skipping it is best except in special circumstances such as running
 37473 redisplay tests in batch mode.   */);
 37474   redisplay_skip_initial_frame = true;
 37475 
 37476   DEFVAR_BOOL ("redisplay-skip-fontification-on-input",
 37477                redisplay_skip_fontification_on_input,
 37478     doc: /* Skip `fontification_functions` when there is input pending.
 37479 If non-nil and there was input pending at the beginning of the command,
 37480 the `fontification_functions` hook is not run.  This usually does not
 37481 affect the display because redisplay is completely skipped anyway if input
 37482 was pending, but it can make scrolling smoother by avoiding
 37483 unnecessary fontification.
 37484 It is similar to `fast-but-imprecise-scrolling' with similar tradeoffs,
 37485 but with the advantage that it should only affect the behavior when Emacs
 37486 has trouble keeping up with the incoming input rate.  */);
 37487   redisplay_skip_fontification_on_input = false;
 37488 
 37489   DEFVAR_BOOL ("redisplay-adhoc-scroll-in-resize-mini-windows",
 37490                redisplay_adhoc_scroll_in_resize_mini_windows,
 37491     doc: /* If nil always use normal scrolling in minibuffer windows.
 37492 Otherwise, use custom-tailored code after resizing minibuffer windows to try
 37493 and display the most important part of the minibuffer.   */);
 37494   /* See bug#43519 for some discussion around this.  */
 37495   redisplay_adhoc_scroll_in_resize_mini_windows = true;
 37496 
 37497   DEFVAR_BOOL ("composition-break-at-point", composition_break_at_point,
 37498     doc: /* If non-nil, prevent auto-composition of characters around point.
 37499 This makes it easier to edit character sequences that are
 37500 composed on display.  */);
 37501   composition_break_at_point = false;
 37502 
 37503   DEFVAR_INT ("max-redisplay-ticks", max_redisplay_ticks,
 37504     doc: /* Maximum number of redisplay ticks before aborting redisplay of a window.
 37505 
 37506 This allows to abort the display of a window if the amount of low-level
 37507 redisplay operations exceeds the value of this variable.  When display of
 37508 a window is aborted due to this reason, the buffer shown in that window
 37509 will not have its windows redisplayed until the buffer is modified or until
 37510 you type \\[recenter-top-bottom] with one of its windows selected.
 37511 You can also decide to kill the buffer and visit it in some
 37512 other way, like under `so-long-mode' or literally.
 37513 
 37514 The default value is zero, which disables this feature.
 37515 The recommended non-zero value is between 100000 and 1000000,
 37516 depending on your patience and the speed of your system.  */);
 37517   max_redisplay_ticks = 0;
 37518 }
 37519 
 37520 
 37521 /* Initialize this module when Emacs starts.  */
 37522 
 37523 void
 37524 init_xdisp (void)
 37525 {
 37526   CHARPOS (this_line_start_pos) = 0;
 37527 
 37528   echo_area_window = minibuf_window;
 37529 
 37530   if (!noninteractive)
 37531     {
 37532       struct window *m = XWINDOW (minibuf_window);
 37533       Lisp_Object frame = m->frame;
 37534       struct frame *f = XFRAME (frame);
 37535       Lisp_Object root = FRAME_ROOT_WINDOW (f);
 37536       struct window *r = XWINDOW (root);
 37537       int i;
 37538 
 37539       r->top_line = FRAME_TOP_MARGIN (f);
 37540       r->pixel_top = r->top_line * FRAME_LINE_HEIGHT (f);
 37541       r->total_cols = FRAME_COLS (f);
 37542       r->pixel_width = r->total_cols * FRAME_COLUMN_WIDTH (f);
 37543       r->total_lines = FRAME_TOTAL_LINES (f) - 1 - FRAME_MARGINS (f);
 37544       r->pixel_height = r->total_lines * FRAME_LINE_HEIGHT (f);
 37545 
 37546       m->top_line = FRAME_TOTAL_LINES (f) - 1;
 37547       m->pixel_top = m->top_line * FRAME_LINE_HEIGHT (f);
 37548       m->total_cols = FRAME_COLS (f);
 37549       m->pixel_width = m->total_cols * FRAME_COLUMN_WIDTH (f);
 37550       m->total_lines = 1;
 37551       m->pixel_height = m->total_lines * FRAME_LINE_HEIGHT (f);
 37552 
 37553       scratch_glyph_row.glyphs[TEXT_AREA] = scratch_glyphs;
 37554       scratch_glyph_row.glyphs[TEXT_AREA + 1]
 37555         = scratch_glyphs + MAX_SCRATCH_GLYPHS;
 37556 
 37557       /* The default ellipsis glyphs `...'.  */
 37558       for (i = 0; i < 3; ++i)
 37559         default_invis_vector[i] = make_fixnum ('.');
 37560     }
 37561 
 37562   {
 37563     /* Allocate the buffer for frame titles.
 37564        Also used for `format-mode-line'.  */
 37565     int size = 100;
 37566     mode_line_noprop_buf = xmalloc (size);
 37567     mode_line_noprop_buf_end = mode_line_noprop_buf + size;
 37568     mode_line_noprop_ptr = mode_line_noprop_buf;
 37569     mode_line_target = MODE_LINE_DISPLAY;
 37570   }
 37571 
 37572   help_echo_showing_p = false;
 37573 }
 37574 
 37575 #ifdef HAVE_WINDOW_SYSTEM
 37576 
 37577 /* Platform-independent portion of hourglass implementation.  */
 37578 
 37579 /* Timer function of hourglass_atimer.  */
 37580 
 37581 static void
 37582 show_hourglass (struct atimer *timer)
 37583 {
 37584   /* The timer implementation will cancel this timer automatically
 37585      after this function has run.  Set hourglass_atimer to null
 37586      so that we know the timer doesn't have to be canceled.  */
 37587   hourglass_atimer = NULL;
 37588 
 37589   if (!hourglass_shown_p)
 37590     {
 37591       Lisp_Object tail, frame;
 37592 
 37593       block_input ();
 37594 
 37595       FOR_EACH_FRAME (tail, frame)
 37596         {
 37597           struct frame *f = XFRAME (frame);
 37598 
 37599           if (FRAME_LIVE_P (f) && FRAME_WINDOW_P (f)
 37600               && FRAME_RIF (f)->show_hourglass)
 37601             FRAME_RIF (f)->show_hourglass (f);
 37602         }
 37603 
 37604       hourglass_shown_p = true;
 37605       unblock_input ();
 37606     }
 37607 }
 37608 
 37609 /* Cancel a currently active hourglass timer, and start a new one.  */
 37610 
 37611 void
 37612 start_hourglass (void)
 37613 {
 37614   struct timespec delay;
 37615 
 37616   cancel_hourglass ();
 37617 
 37618   if (FIXNUMP (Vhourglass_delay)
 37619       && XFIXNUM (Vhourglass_delay) > 0)
 37620     delay = make_timespec (min (XFIXNUM (Vhourglass_delay),
 37621                                   TYPE_MAXIMUM (time_t)),
 37622                            0);
 37623   else if (FLOATP (Vhourglass_delay)
 37624            && XFLOAT_DATA (Vhourglass_delay) > 0)
 37625     delay = dtotimespec (XFLOAT_DATA (Vhourglass_delay));
 37626   else
 37627     delay = make_timespec (DEFAULT_HOURGLASS_DELAY, 0);
 37628 
 37629   hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
 37630                                    show_hourglass, NULL);
 37631 }
 37632 
 37633 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
 37634    shown.  */
 37635 
 37636 void
 37637 cancel_hourglass (void)
 37638 {
 37639   if (hourglass_atimer)
 37640     {
 37641       cancel_atimer (hourglass_atimer);
 37642       hourglass_atimer = NULL;
 37643     }
 37644 
 37645   if (hourglass_shown_p)
 37646     {
 37647       Lisp_Object tail, frame;
 37648 
 37649       block_input ();
 37650 
 37651       FOR_EACH_FRAME (tail, frame)
 37652         {
 37653           struct frame *f = XFRAME (frame);
 37654 
 37655           if (FRAME_LIVE_P (f) && FRAME_WINDOW_P (f)
 37656               && FRAME_RIF (f)->hide_hourglass)
 37657             FRAME_RIF (f)->hide_hourglass (f);
 37658 #ifdef HAVE_NTGUI
 37659           /* No cursors on non GUI frames - restore to stock arrow cursor.  */
 37660           else if (!FRAME_W32_P (f))
 37661             w32_arrow_cursor ();
 37662 #endif
 37663         }
 37664 
 37665       hourglass_shown_p = false;
 37666       unblock_input ();
 37667     }
 37668 }
 37669 
 37670 /* Return a correction to be applied to G->pixel_width when it is
 37671    displayed in MOUSE_FACE.  This is needed for the first and the last
 37672    glyphs of text inside a face with :box when it is displayed with
 37673    MOUSE_FACE that has a different or no :box attribute.
 37674    ORIGINAL_FACE is the face G was originally drawn in, and MOUSE_FACE
 37675    is the face it will be drawn in now.  ROW is the G's glyph row and
 37676    W is its window.  */
 37677 static int
 37678 adjust_glyph_width_for_mouse_face (struct glyph *g, struct glyph_row *row,
 37679                                    struct window *w,
 37680                                    struct face *original_face,
 37681                                    struct face *mouse_face)
 37682 {
 37683   int sum = 0;
 37684 
 37685   bool do_left_box_p = g->left_box_line_p;
 37686   bool do_right_box_p = g->right_box_line_p;
 37687 
 37688   /* This is required because we test some parameters of the image
 37689      slice before applying the box in produce_image_glyph.  */
 37690   if (g->type == IMAGE_GLYPH)
 37691     {
 37692       if (!row->reversed_p)
 37693         {
 37694           struct image *img = IMAGE_FROM_ID (WINDOW_XFRAME (w),
 37695                                              g->u.img_id);
 37696           do_left_box_p = g->left_box_line_p &&
 37697             g->slice.img.x == 0;
 37698           do_right_box_p = g->right_box_line_p &&
 37699             g->slice.img.x + g->slice.img.width == img->width;
 37700         }
 37701       else
 37702         {
 37703           struct image *img = IMAGE_FROM_ID (WINDOW_XFRAME (w),
 37704                                              g->u.img_id);
 37705           do_left_box_p = g->left_box_line_p &&
 37706             g->slice.img.x + g->slice.img.width == img->width;
 37707           do_right_box_p = g->right_box_line_p &&
 37708             g->slice.img.x == 0;
 37709         }
 37710     }
 37711 
 37712   /* If the glyph has a left box line, subtract it from the offset.  */
 37713   if (do_left_box_p)
 37714     sum -= max (0, original_face->box_vertical_line_width);
 37715   /* Likewise with the right box line, as there may be a
 37716      box there as well.  */
 37717   if (do_right_box_p)
 37718     sum -= max (0, original_face->box_vertical_line_width);
 37719   /* Now add the line widths from the new face.  */
 37720   if (g->left_box_line_p)
 37721     sum += max (0, mouse_face->box_vertical_line_width);
 37722   if (g->right_box_line_p)
 37723     sum += max (0, mouse_face->box_vertical_line_width);
 37724 
 37725   return sum;
 37726 }
 37727 
 37728 /* Get the offset due to mouse-highlight to apply before drawing
 37729    phys_cursor, and return it in OFFSET.  ROW should be the row that
 37730    is under mouse face and contains the phys cursor.
 37731 
 37732    This is required because the produce_XXX_glyph series of functions
 37733    add the width of the various vertical box lines to the total width
 37734    of the glyphs, but that must be updated when the row is put under
 37735    mouse face, which can have different box dimensions.  */
 37736 static void
 37737 get_cursor_offset_for_mouse_face (struct window *w, struct glyph_row *row,
 37738                                   int *offset)
 37739 {
 37740   int sum = 0;
 37741   /* Return because the mode line can't possibly have a cursor. */
 37742   if (row->mode_line_p)
 37743     return;
 37744 
 37745   block_input ();
 37746 
 37747   struct frame *f = WINDOW_XFRAME (w);
 37748   Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (f);
 37749   struct glyph *start, *end;
 37750   struct face *mouse_face = FACE_FROM_ID (f, hlinfo->mouse_face_face_id);
 37751   int hpos = w->phys_cursor.hpos;
 37752   end = &row->glyphs[TEXT_AREA][hpos];
 37753 
 37754   if (!row->reversed_p)
 37755     {
 37756       if (MATRIX_ROW_VPOS (row, w->current_matrix) ==
 37757           hlinfo->mouse_face_beg_row)
 37758         start = &row->glyphs[TEXT_AREA][hlinfo->mouse_face_beg_col];
 37759       else
 37760         start = row->glyphs[TEXT_AREA];
 37761     }
 37762   else
 37763     {
 37764       if (MATRIX_ROW_VPOS (row, w->current_matrix) ==
 37765           hlinfo->mouse_face_end_row)
 37766         start = &row->glyphs[TEXT_AREA][hlinfo->mouse_face_end_col];
 37767       else
 37768         start = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
 37769     }
 37770 
 37771   /* Calculate the offset by which to correct phys_cursor x if we are
 37772      drawing the cursor inside mouse-face highlighted text.  */
 37773 
 37774   for ( ; row->reversed_p ? start > end : start < end;
 37775           row->reversed_p ? --start : ++start)
 37776     sum += adjust_glyph_width_for_mouse_face (start, row, w,
 37777                                               FACE_FROM_ID (f, start->face_id),
 37778                                               mouse_face);
 37779 
 37780   if (row->reversed_p)
 37781     sum = -sum;
 37782 
 37783   *offset = sum;
 37784 
 37785   unblock_input ();
 37786 }
 37787 #endif /* HAVE_WINDOW_SYSTEM */
/* [<][>][^][v][top][bottom][index][help] */